JavaDay06-封装、继承、多态

一、封装

①private ②get/set

1、变量或方法前加了private后变为私有属性和私有方法，任何其他类无法直接访问或修改，实现封装
2、间接访问私有属性和私有方法：通过在该类中定义public方法（get/set）访问该类中的私有属性和私有方法

封装的意义：

1、提高程序的安全性，保护数据；
2、隐藏代码的实现细节；
3、统一接口；
4、系统可维护性增加了。

public class FengZhuang {
    //通过private修饰符实现封装
    private String name;
    private int age;
    //封装后通过get/set两个public方法修改属性，可以进行合法化判断
    public int getAge() {
        return this.age;
    }
    //设置年龄段必须在0-300之间
    public void setAge(int age) {
        if (age<0||age>300){
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

二、继承

关于继承：是子类和父类之间的关系

1、继承了父类以后就拥有了父类的public方法
2、ctrl+h召唤族谱
3、Java中所有的类都直接或者间接的继承了Object类

父类和子类的构造器调用问题

1、在主程序中new一个子类以后，先调用父类的构造器并且初始化其属性和常量池。后调用子类的构造器及其属性、常量池
2、super();此方法写在子类的方法或者构造器中第一行，用于调用父类的构造器。只能在继承关系下才能使用
- super()，调用父类的无参构造器
- super(有参数)， 调用父类的有参构造器
- 无super()，默认调用父类的无参构造器
- 若父类中仅定义了有参构造，那么子类的构造器中必须存在super(有参数)
3、this()调用本类的构造方法

在子类中调用变量

1、在方法体内调用实例变量：this.变量；
2、在方法体内调用父类的实例变量：super.变量；
3、子类继承父类后，直接使用父类的静态变量和静态方法。

在子类中调用方法

1、method();调用子类中的方法
2、this.method();调用子类中的方法
3、super.method();调用父类中的public方法

//主方法
public class Application {
    public static void main(String[] args) {
        //这里可以debug查看new一个子类对象时子类和父类的调用顺序
        Student student = new Student();
        //测试this和super
        student.test("xiaozhangzhang");
        //测试子类和父类构造器的调用顺序
        student.test2();
    }
}

//Student的父类
class Person {
    static double PI=3.1415;
    String name = "shix";
    int age=10;
    //父类Person的无参构造器
    public Person() {
        System.out.println("父类Person的无参构造器执行了");
    }
    //父类Person的有参构造器
    public Person(String name) {
        this.name = name;
    }
    public void say(){
        System.out.println("父类Person的say");
    }
}

//Person的子类
public class Student extends Person{
    public String name="william";
    int age=10;
    //子类Student的无参构造器
    //继承-先执行父类 再执行子类
    public Student() {
        super(" ");//隐藏代码-调用父类构造器，当父类定义了无参构造时可以不写（不写的话默认调用父类的无参构造器，所以父类的无参构造器必须存在），但写的话必须写在子类构造器的第一行;当父类定义了有参构造未无参构造时，必须写super(参数)。
        System.out.println("子类Student的无参构造器执行了");
    }
    //子类Student的有参构造器
    public Student(String name) {
        super();
        this.name = name;
        System.out.println("子类Student的有参构造器执行了");
    }

    public void say(){
        System.out.println("子类Student的say");
    }
    public void test(String name) {
        System.out.println(name);//局部变量，形参的值
        System.out.println(this.name);//类变量的值
        System.out.println(super.name);//访问父类中的属性
    }
    private void talk(){
        System.out.println("子类Student的talk");
    }
    public void test2(){
        this.talk();
        talk();
        say();//子类Student的say
        this.say();//子类Student的say
        super.say();//父类Person的say
    }
}

重写：

1、存在于继承关系，子类重写父类的方法；
2、方法名相同 参数列表相同 方法体不同；
3、修饰符：范围可以扩大 但不能缩小。public>protected>default；
4、抛出异常：范围可以缩小 但不能扩大。

• 不能重写属性，不能重写static方法。static应该由类调用而非对象
• private方法不能被重写，但可以通过修改修饰符扩大范围的方式实现父类中的private方法
• 快捷键：alt+insert override

//主方法
public class Application {
    public static void main(String[] args) {
        A a=new A();
        a.test0();
        a.test1();
        B b=new A();
        //b.test();
        A.testStatic();//继承了父类B的静态方法，通过类A调用而非对象
    }
}

//父类
public abstract class B {
    //public方法能够被重写
    public void test0(){
        System.out.println("B-Public");
    }
    //private方法不能被重写
    private void test1(){
        System.out.println("B-Private");
    }
    //static方法不能被重写
    public static void testStatic(){
        System.out.println("B-Static");
    }

}

//子类
public class A extends B{
    //方法的重写
    @Override
    public void test0() {
        super.test0();
    }
    //扩大修饰符间接修改private方法
    public void test1() {
        System.out.println("A-Private");
    }
}

三、多态

父类 变量名=new 子类；//相当于通过右边的子类更新父类中被重写的原方法

多态-条件：

1、有继承关系 ClassCastException（类型转换异常）
2、子类重写了父类方法
3、父类引用指向子类对象

多态-注意点：

1、父类引用不能调用子类中独有的方法
2、父类引用不能调用父类中被子类重写了的原方法
3、父类引用可以调用本类中独有的方法
4、父类引用可以调用子类中被子类重写的方法
5、子类引用可以调用父类中独有的方法
6、多态是方法的多态
7、以下方法不能被重写：final、private、static

instanceof

1、三种结果：true、false、编译报错
2、左边是指向对象的引用变量
3、右边是类
4、判断左边的对象是否直接或间接是右边类的实例

引用类型的类型转换

1、低转高，直接转，适用于将 子类引用指向子类对象 转成 父类引用指向子类对象
2、高转低，强转，适用于将 父类引用指向子类对象 转成 子类引用指向子类对象
3、子类转成父类后，可能丢失子类的一些方法

//主方法
public class Application {
    public static void main(String[] args) {
        //A为子类 子类引用指向子类对象
        A a = new A();
        //子类调用子类中重写的父类方法
        a.say();
        //B为父类 父类引用指向子类对象
        B b=new A();
        //========================================================================================================================
        //父类引用只能调用父类中的方法和子类重写的父类方法，无法调用子类中独有的方法
        b.say();//此方法被子类重写，不在调用父类中的原方法
        b.run();//父类中独有的方法，子类继承后拥有此方法
        a.eat();//子类调用子类中独有的方法，父类无法调用
        a.run();//子类可以调用父类中的方法
        //========================================================================================================================
        //instanceof-判断左边的对象是否是右边的类的实例（包含本类的实例、直接或间接子类的实例）。如果不在同一棵继承树上，则会编译出错
        System.out.println(b instanceof A);//本身-true
        System.out.println(b instanceof B);//父类-true
        System.out.println(b instanceof Object);//父类的父类-true
        System.out.println(b instanceof C);//同一棵继承树但没有继承关系-false
        //=====================================================
        System.out.println(a instanceof A);//本身-true
        System.out.println(a instanceof B);//父类-true
        System.out.println(a instanceof Object);//父类的父类-true
        //System.out.println(a instanceof C);//不在同一棵继承树-编译出错
        //=====================================================
        B b1 = new B();
        System.out.println(b1 instanceof A);//子类-false
        System.out.println(b1 instanceof B);//本身-true
        System.out.println(b1 instanceof Object);//父类-true
        System.out.println(b1 instanceof C);//子类-false
        //========================================================================================================================
        //类型转换
        A aa = new A();//son
        B bb = new B();//father
        //son-->father
        B bb1=aa;//直接转 低转高 转换后，bb1是一个B类型，指向A的实例对象
        //father-->son
        if (bb1 instanceof A){
            A aa1=(A)bb1;//强转 高转低 转换后，aa1指向A的实例对象
            A aa2=(A)bb;//报错，不可以这样转，转换后A类引用指向了B的实例对象，但是父类的实例对象不可以由子类指向
            aa1.eat();
        }
        bb1.run();
        bb1.say();//say-A
    }
}

//父类
public class B {
    public void say(){
        System.out.println("say-B");
    }
    //父类独有方法
    public void run(){
        System.out.println("run-B");
    }
}

//子类
public class A extends B{
    @Override
    public void say() {
        System.out.println("say-A");
    }
    //子类独有方法
    public void eat(){
        System.out.println("eat-A");
    }
}

//子类
public class C extends B{
}