封装，继承，多态

一、封装

1、什么是封装 ？

对象代表什么 就得封装对应的数据 并提供数据对应的行为（方法）
例如：人关门 这个动作 对象代表门，封装门的状态（关闭或者打开）数据，提供关门的方法，门是自己关上的 人只是调用了关门的方法

2、封装的思想，以及封装思想的好处？

1.让编程简单化，有什么事，找对象，再调用方法
2.降低学习成本，少学，少记，
3.不用记对象的很多方法，需要时在Java API查询就行

3、如何进行更好的封装

1.一般会把成员变量用private隐藏起来 对外不能访问
2.提供public修饰的 getter和setter方法暴露其取值和赋值

public class Test {//新建一个测试类
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(21);
        s.getAge();
        System.out.println(s.getAge());
    }
}

public class Student {
    //1.成员变量 用private修饰，代表私有的或者隐藏的 只能在本类中使用
    private int age;

    /*
    提供  setter和getter方法赋值和取值
     */
    public void setAge(int age){
        if(age >= 0 && age <= 200){
            this.age = age;
        }else {
            System.out.println("您输入的年龄不正确！");
        }
    }
    public int getAge(){
        return age;
    }
}

二、继承

1.继承概述，使用继承的好处？

继承概述：java允许一个类通过extends与另一个类建立父子关系，子类继承父类之后，就可以得到父类的属性和方法，这就是继承

格式：子类 extends 父类

//狗类继承动物类
public class Dog extends Animal{
}

继承的好处：提高代码的复用性。多个子类的相同代码可以放在父类中，增强了类的扩展性

2.继承的特点

1.子类可以继承父类得到属性和行为，但是子类不能继承父类的构造器
2.Java是单继承模式：一个类只能继承一个直接父类
3.Java不支持多继承，但是支持多层继承

//A只能继承一个类 不能继承多个类
public class A extends B C {
}

4.Java中所有的类都是Object的子类

3.继承后成员变量和成员方法的访问特点

1.在子类方法中访问成员 采用就近原则（子类局部没有找子类成员，子类都没有就找父类，父类再没有就报错）
2.子类用this.关键字访问的是子类自己的成员变量
3.子父类中出现重名的成员，在子类中访问父类成员需要用到 super.父类成员方法/父类成员变量

4.继承后的方法重写

1.继承后的方法重写概念：子类重写了一个申明与父类一样的方法，覆盖父类的方法
2.@Override 是放在重写后的方法上，作为重写是否正确的校验注解，且可读性好
3.方法重写的注意事项和要求
①重写方法的名称，形参列表必须与被重写方法的名称和形参列表一致
②私有的方法不能被重写
③子类重写父类方法时，访问权限必须大于或者等于父类
④子类不能重写父类的静态方法

//测试类
public class Test {  
    public static void main(String[] args) {
        NewPhone h = new NewPhone();
        h.call();
        h.sendMsg();
    }
}

/*
    旧手机 作为父类
 */
class Phone{
        public void call(){
            System.out.println("打电话");
        }

        public void sendMsg(){
            System.out.println("发短信");
        }
}

/*
    新手机 作为子类
 */
class NewPhone extends Phone{
    @Override//重写校验注解，加上之后，这个方法必须是正确重写的，这样更安全
             //重写方法的名称，形参列表必须与被重写的名称和形参列表一致
    //重写的方法
    public void call(){
        super.call();//先用父类的基本功能
        System.out.println("开始视频通话");
    }
    @Override
    //重写的方法
    public void sendMsg(){
        super.sendMsg();//先用父类的基本功能
        System.out.println();
        System.out.println("发送语音和图片");
    }
}

#### 5.继承后：子类构造器的特点？ 特点：子类的全部构造器默认都会先访问父类中的无参的构造器，再执行自己的构造器 代码层面：默认子类构造器的第一行都有一个super()访问父类的无参数构造器，写不写都有

public class Animal {
    public Animal(){
        System.out.println("父类无参数构造器被执行了");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        //目标；认识继承后子类构造器的特点
        //特点：子类的全部构造器默认会先访问父类的无参构造器
        Dog d1 = new Dog();
        System.out.println(d1);
}

//狗继承了动物类
public class Dog extends Animal{
/*
    子类无参数构造器
 */
    public Dog(){
        super();//写不写都有，默认找父类的无参数构造器
        System.out.println("子类Dog无参数构造器被执行了");
    }
 }

输出结果： 父类无参数构造器被执行了 子类Dog无参数构造器被执行了 d1对象的内存地址

6.继承后 ：子类构造器访问父类有参数构造器

调用父类的有参数构造器来初始化继承自父类的数据

7.this，super关键字使用

1.this 访问当前对象的成员方法和成员变量
2.super 在子类方法中指定访问父类的成员方法和成员变量
3.this(…) 访问本类兄弟构造器
4.super(…)在本类中构造器中指定访问父类的构造器
注意事项：super(…)和this(…)必须要在第一行，两者不能共存一个构造器中

二、多态

1，多态概念

同类型的对象，执行同一个行为，会表现出不同的行为特征

常见形式：父类对象名 对象名称 = new 子类构造器

       Animal a1 = new Dog();
        a1.run();//编译看左边，运行看右边
        System.out.println(a1.name);//编译看左边，运行也看左边

                  接口 对象名称 = new 实现类构造器


多态成员访问特点:①方法调用：编译看左边，运行看右边

                              ②变量调用：编译看左边，运行也看左边

多态的前提：有继承/实现的关系；也有父类引用指向子类对象；有方法重写

2、多态的优势

1.在多态形式下，右边对象可以实现解耦合，便于扩展和维护

Animal a = new Dog();//根据业务需求 可以new 其他子类
a.run;//后续业务行为随着对象而变，后续代码无需修改

2.定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利

3.多态的引用数据类型转换

1、自动类型转换（从子类到父类）：子类对象赋值给父类类型的变量指向

Animal a = new Dog();
a.run;

2、强制类型转换（从父类到子类）：子类 对象名 = (子类) 父类类型的变量
作用：可以解决多态下的劣势，可以实现调用子类独有的功能

Animal a1 = new Brid();
a1.run;
Bird c = (Bird) a1;//从父类类型转换成子类类型 必须强制转换
c.fly();

Java建议强转转换前使用 instanceof 判断当前对象的真实类型，再进行强制转换
变量名 instanceof 真实类型

强制类型转换注意问题

①可以转换成真正的子类类型，从而调用子类独有功能
②有继承关系/实现的2个类型就要可以进行强制转换，编译无问题
③运行时，如果发现强制转换后的类型不是对象真实类型 则会报错
④类型转换异常：ClassCastException