本文链接： https://blog.csdn.net/weixin_44494648/article/details/99403911

继承，封装，多态是面向对象的三大特征

封装–编程语言对客观世界的模拟

封装是指将对象的状态信息隐藏在对象的内部，不允许外部直接访问，对象的内部信息，而是通过该类所提供的方法实现对内部信息的操作和访问

封装可以实现以下的目的：

隐藏类的实现细节
让使用者只能通过事先预定的方法来访问数据，从而可以在方法中加入控制逻辑，限制队成员变量的不合理访问。
便于修改，提高了代码的可维护性

访问控制符范围由大到小

public（公共访问权限）:同一个类，同一个包，子类，以及全局范围都可以访问，可访问范围最大
protected （子类访问权限):同一个类，同一个包，以及其子类可以访问，同一个报中的其他类可以访问，不同包中的子类也可以访问，该修饰词修饰方法一般是用于子类要重写该方法。
default：（包访问权限）当不使用修饰符修饰时，访问权限为default，同一个包中可以访问。
private：（当前类访问权限）可范围最小，只在当前类中可以访问，子类无法继承；

get与set方法

使用private 对类中的属性信息进行隐藏，外部访问，可以将get,set方法暴露出去，在这些方法中加入相关的限制，可以保证修改数据时的安全；
使用：当一个变量名为 abc时，其对应的方法为 getAbc(),setAbc();

代码：

class Student01{
//属性私有化，必须通过方法访问
    private int age;
    private String name;
    private String ID;

    public int getAge() {
        return age;
    }

//可以在相应的方法中增加对数据安全的检查
    public void setAge(int age) {
        if(age<0){
            System.out.println("输入错误");
        }
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }
}

继承–一个类对另一个类的扩展

另一篇博客：继承
补充：
关于构造器

任何类都有构造器，没有写的是默认构造器，一个类被创建，就要先调用构造器
默认构造器会赋初始值给各个变量
一旦自己提供了构造器，系统就不会自动生成构造器，所以一添加构造器会在加一个空构造器
构造器相当于一个函数，可以重载，但不能有返回值

代码

 public Student01(int age, String name, String ID) {//有参构造器
        this.age = age;
        this.name = name;
        this.ID = ID;
    }

 public Student01() {//无参构造器
    }

构造器与继承

发生继承时，子类不会获得父类的构造器，但是子类的构造器里可以调用父类的构造器，子类调父类的构造器，通过super

//该类继承上面的类
class Student02 extends Student01{
	//该类中多了班级属性
    private String clazz;
     public Student02(){//自己的构造器，默认掉父类的空构造器
    }
    public Student02(){//自己的构造器，和上边构造器相同
        super();//自己的构造器可以调用父类的构造器
        
    }
    public Student02(int a,String b,String c){
        super(a,b,c);//调用父类的有参构造器

    }
    public Student02(String clazz){//默认调用父类的构造器
        this.clazz=clazz;
    }        
}

注意：继承时，父类的可被继承的属性对于子类是透明的，所以一定程度的破坏了父类的封装，子类可能会恶意篡改父类

多态

引用变量的两种类型：一种是编译时类型，一种是运行时类型，编译类型是声明变量时对变量的指定类型，运行时类型是真正new 出来的对象的是是么类型，当有继承时，父类引用就可以指向子类对象

class People01 {
   int age;
    String name;
   String ID；
   //父类方法
 void sleep(){
        System.out.println("普通人：10点睡觉");
    }
    
}

class Student02 extends People01{
  String clazz;
  //子类方法
  void sleep(){
        System.out.println("学生;12点睡觉");
    }
}

上面的代码中（为了使代码简洁，没有进行封装）学生类继承人类，创建对象时

People01 xiaoLi=new Student02();//创建一个人类对象，但他实际上是一个学生对象
 xiaoLi.sleep();//结果：学生;12点睡觉

执行代码，输出结果，学生;12点睡觉，xaioLi是一个学生，所以，会调用到学生的方法。

 People01 xiaozhaang=new People01();
xiaozhang.sleep();//普通人：10点睡觉

执行代码，输出结果: 普通人：10点睡觉,这就是多态
子类赋值给父类，系统自动完成转型，父类到子类要强转，并且该父类一定要是一个指向该子类的引用，否则就会出错。
instanceof运算符
用于判断一个对象是不是这个类的对象，或者其子类对象，

xiaoli instanceof Student02;//是学生，返回结果就是true
xiaowang instanceof People01://不是学生，返回值是false

强转类型之前最好做一下判断

强转类型的必要性：由于父类虽然指向子类，但却不能调用子类的方法，因为其编译时类型还是父类，看不到子类的方法，所以无法编译，这时就必须强转了；

关于JAVA大的继承，封装与多态--Java学习笔记

继承，封装，多态是面向对象的三大特征

封装–编程语言对客观世界的模拟

继承–一个类对另一个类的扩展

多态

猜你喜欢