封装、继承、多态

一.封装

package Demo;

//类     private私有
public class student {
//属性私有
//名字
private String name;
//学号
private int id;
//性别
private char sex;
private int age; public int getAge() {
return age;
} public void setAge(int age) {
if (age>120 || age<0){
this.age=3;
}else{
this.age = age;
}
}
//提供一些可以操作这个属性的方法
//提供一些public的set、get方法 //get,获得这个数据
public String getName(){
return name;
}
//set,给这个数据设置值
public void setName(String name){
this.name=name;
} //alt+insert自动生成get、set方法 //学习() //睡觉()
}

package Demo;

public class Application {
public static void main(String[] args) {
student s1 = new student(); String name = s1.getName();
s1.setName("LiLiLiYH");
System.out.println(s1.getName());//LiLiLiYH
s1.setAge(999);//不合法的
System.out.println(s1.getAge());
}
}

二.继承

1.什么是继承

package Demo.demo05;

//人   父类
//在java中,所有的类都默认直接或间接继承object
public class Person /* entends Object */{
private int money=1_0000;
public int getMoney() {
return money;
} public void setMoney(int money) {
this.money = money;
} public void say(){
System.out.println("说了一句话"); }
}

package Demo.demo05;

//学生是人   派生类/子类
//子类继承了父类,就会有父类的全部方法
public class Student extends Person{ //ctrl+h
public static void main(String[] args) {
Student student = new Student();
student.say();//说了一句话
System.out.println(student.getMoney());//10000
} }

java有四种权限修饰符:

项目 public protected default private
同一个类 yes yes yes yes
同一个包 yes yes yes no
子父类 yes yes no no
不同包 yes no no no

附:类间的方法的调用

如果不在一个类中,静态方法调用其他类中的的静态方法,必须通过:

类名.静态方法();

如果不在一个类中,静态方法调用其他类的非静态方法,需要导入该类的包。以及通过创建对象调用。


在不同类中,非静态方法调用其他类的静态方法,需要通过导入该类中的包,并且需要通过类名来调用。

在不同类中,非静态方法调用其他类的非静态方法时,需要导入该类中的包,还需要通过创建对象来调用。

2.Super详解

package Demo.demo05;

//人   父类
//在java中,所有的类都默认直接或间接继承object
public class Person /* entends Object */{
public Person() {
System.out.println("Person无参构造执行了");
} protected String name="LiLiLiYH";
public void print(){
System.out.println("person");
}
}

package Demo.demo05;

//学生是人   派生类/子类
//子类继承了父类,就会有父类的全部方法
public class Student extends Person{
public Student() {
//隐藏代码,调用了父类的无参构造
super();//调用父类构造器,必须要在子类构造器的第一行
System.out.println("Student无参构造执行了");
} public void print(){
System.out.println("student");
}
public void test2(){
print();//student
this.print();//student
super.print();//person
}
// private String name="李";
// public void test(String name){
// System.out.println(name);//Li
// System.out.println(this.name);//李
// System.out.println(super.name);//LiLiLiyh
// } }

package Demo.demo05;

public class Application {
public static void main(String[] args) {
Student student = new Student();
//student.test("Li");
student.test2();
}
}

super注意点:

  1. super调用父类的构造方法,必须在构造方法的第一个
  2. super必须只能出现在子类的方法或构造方法中
  3. super和this不能同时调用构造方法

VS

this:

  • 代表的对象不同

    this:本身调用者这个对象

    super:代表父类对象的应yong

  • 前提

    this:没有继承也可以使用

    super:只有在继承条件才可以使用

  • 构造方法

    this:本类的构造

    super:父类的构造

CSDN上有个写的很好,这里推荐可以看下:super&this

3.方法重写

package Demo.demo05;

public class B {
protected void test(){
System.out.println("B>=test");
}
}

package Demo.demo05;

public class A extends B{
//Override重写
@Override//注解:有功能的注释
public void test() {
System.out.println("A>=test");
}
}

package Demo.demo05;

public class Application {

    //静态方法和非静态方法区别很大
//静态方法:方法的调用只和左边定义的数据类型有关
//非静态:重写
public static void main(String[] args) {
A a = new A();
a.test();//A>=test //父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();
} }

三.多态

1.什么是多态

动态编译:类型:可拓展性

package Demo.demo05;

public class Person {
public void run(){
System.out.println("run");
} }

package Demo.demo05;

public class Student extends Person{
@Override
public void run() {
System.out.println("son");
} public void eat(){
System.out.println("eat");
}
}

package Demo.demo05;

public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person(); //可以指向的引用类型就不确定了:父类的引用指向子类 //Student能调用的方法,都是自己的或者继承父类的
Student s1 = new Student();
//Person父类型,可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student(); s2.run();//子类重写了父类的方法,执行子类的方法
s1.run(); //对象能执行哪些方法。主要看对象左边的类型,和右边的关系大不大
s1.eat();
//s2.eat();报错
((Student) s2).eat();//强转
}
}

个人感觉初学听完狂神说的这节视频还是有点迷茫,另外又找了个视频可以看下

多态

这个逻辑感觉更清晰些


2.instanced和类型转换

instance of 判断一个对象是什么类型

先建立一个父类Person

再建立两个子类Teacher和Student

测试类中代码如下:

package Demo01;

public class Application {
public static void main(String[] args) {
Object object = new Student();
//相当于 Student student1 = new Student();
// Object object=student1; //Object>String
//Object>Person>Student
//Object>Person>Teacher
//System.out.println(x instanceof y);能不能编译通过
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false System.out.println("============================"); Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译报错 System.out.println("======================"); Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译报错
//System.out.println(student instanceof String);//编译报错 }
}

类型转换


父类

package Demo01;

public class Person {
public void run(){
System.out.println("run");
}
}

子类

package Demo01;

public class Student extends Person {
public void go(){
System.out.println("go");
}
}

测试类

package Demo01;

public class Application {
public static void main(String[] args) {
//类型之间的转化:低转高自动转,高转低强转 //高 低
//子类转成父类,可能丢失自己的本来的一些方法
Person s = new Student(); //现在s是Person类型,s.go();会报错
//将s转换为Student类型,我们就可以使用Student类型的方法了
Student s1=(Student)s;
s1.go();
//把上面两句话写成一句话((Student) s).go(); }
}

Day14-封装、继承、多态的更多相关文章

  1. java面向对象(封装-继承-多态)

    框架图 理解面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能行为 面向对象将功能封装进对象,强调具备了功能的对象. 面向对象是基于面向过程的. 面向对象的特点 ...

  2. 浅谈学习C++时用到的【封装继承多态】三个概念

    封装继承多态这三个概念不是C++特有的,而是所有OOP具有的特性. 由于C++语言支持这三个特性,所以学习C++时不可避免的要理解这些概念. 而在大部分C++教材中这些概念是作为铺垫,接下来就花大部分 ...

  3. Java三大特性(封装,继承,多态)

    Java中有三大特性,分别是封装继承多态,其理念十分抽象,并且是层层深入式的. 一.封装 概念:封装,即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别:将抽象得到的数据 ...

  4. php面向对象 封装继承多态 接口、重载、抽象类、最终类总结

    1.面向对象 封装继承多态  接口.重载.抽象类.最终类 面向对象 封装继承多态  首先,在解释面向对象之前先解释下什么是面向对象? [面向对象]1.什么是类? 具有相同属性(特征)和方法(行为)的一 ...

  5. Java基础——面向对象(封装——继承——多态 )

    对象 对象: 是类的实例(实现世界中 真 实存在的一切事物 可以称为对象) 类: 类是对象的抽象描述 步骤: 1.定义一个类 (用于 描述人:) ( * 人:有特征和行为) 2.根据类 创建对象 -- ...

  6. Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

    Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1.面向对象的三大特性: (1)继承 ​ 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以 ...

  7. OOP三大核心封装继承多态

    OOP支柱 3 个核心:封装 继承 多态 封装就是将实现细节隐藏起来,也起到了数据保护的作用. 继承就是基于已有类来创建新类可以继承基类的核心功能. 在继承中 另外一种代码重用是:包含/委托,这种重用 ...

  8. python面向对象(封装,继承,多态)

    python面向对象(封装,继承,多态) 学习完本篇,你将会深入掌握 如何封装一个优雅的借口 python是如何实现继承 python的多态 封装 含义: 1.把对象的属性和方法结合成一个独立的单位, ...

  9. C语言设计模式-封装-继承-多态

    快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...

  10. java四大特性理解(封装继承多态抽象)

    封装: 封装是把过程和数据包围起来,对数据的访问只能通过已定义的接口.面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治.封装的对象,这些对象通过一个受保护的接口访问其他对象.封装是一 ...

随机推荐

  1. ctfshow web入门 命令执行 37-39

    37-39 基于 GET 传参的 include() 38.39 是 37 的变种 分析 伪协议常用于文件包含漏洞中 文件包含函数有:include.include_once.require.requ ...

  2. PyTorch Geometric(pyg)学习

    参考2个链接: 第十六课.Pytorch-geometric入门(一)_tzc_fly的博客-CSDN博客_pytorch-geometric 第十七课.Pytorch-geometric入门(二)_ ...

  3. Windows系统的显示器校正

    莫名其妙的显示器显示的内容整体向上偏移,导致一些页面在最大化窗口时,看不见页面的标题,及操作按钮,如页面的关闭,缩小按钮. 解决方法:点击显示器下方的menu按钮,找到 设定 选项,再选择 复位 即可 ...

  4. 向mysql插入数据是出现Incorrect string value错误

    在向Mysql中添加中文数据时,报错(incorrect string value ) 字符转换不正确 插入语句:mysql>  insert into user1 (name,password ...

  5. 在Mac的哪里可以找到bashrc文件

  6. Linux&Android相关常用命令汇总记录

    Linux&Android相关常用命令汇总记录 0@Linux&Android系统命令行下如何查看命令的帮助信息: command --help 1@在Linux系统中,设备分为三类, ...

  7. ubuntu22.04LTS下编译glfw

    环境准备 # 预装cmake sudo apt install cmake # 下载源码 git clone https://github.com/glfw/glfw.git 编译 # cmake初始 ...

  8. 为什么 A 能 ping 通 B,B 却不能 ping 通 A ?

    有开发小哥咨询了一个问题,记录一下处理过程分享给有需要的朋友. 问题如下: A.B 两台开发服务器连接交换机,并且 A.B 两台服务器的 IP 地址设置为同一个网段,却发现 A 能 ping 通 B ...

  9. Oracle JDK 和 OpenJDK 有什么区别?

    OpenJDK是Sun在2006年末把Java开源而形成的项目,这里的"开源"是通常意义上的源码开放形式,即源码是可被复用的,例如IcedTea.UltraViolet都是从Ope ...

  10. ssh远程连接服务器

    远程连接服务器及压缩文件与解压 1 终端连接 ssh -p 端口号 用户名@地址 例如:ssh -p 80 name@host 每次远程连接,使用账号和密码登录,有可能使得端口被监听到,从而导致挖矿情 ...