Java-面向对象（封装、继承和多态）

相关要点说明及体现

注意点1

多层继承
Object是Java中所有类的顶层父类，所有类都直接或间接地继承Object

public class A extends Object{ //A继承Object
    public void showA(){
        System.out.println("A");
    }
}

public class B extends A{
    public void showB1(){
        System.out.println("B1");
    }
    public void showB2(){
        System.out.println("B2");
    }
}

public class C extends B{

}

public class Test extends Object{
    public static void main(String[] args) {
        B b = new B();
        C c = new C();
        b.showA();//B继承A
        c.showB1();//C继承B
        c.showB2();
    }
}

注意点2

变量的访问，采用就近原则

public class Fath {
    int num1 = 11;
    int num2 = 22;
}

public class Son extends Fath{
    int num2 = 33;
    int num3 = 44;
    public void show(){
        int num3 = 55;
        System.out.println(num3);//55
        System.out.println(num2);//33
        System.out.println(num1);//11
    }
}

public class Test {
    public static void main(String[] args) {
        new Son().show();//变量的寻找 遵循就近访问原则
    }
}

注意点3

代码块执行顺序1——>8

class Fath {
    static {
        System.out.println("静态代码块Father"); //3
    }

    {
        System.out.println("构造代码块Father");//5
    }

    public Fath() {
        System.out.println("构造方法Father");//6
    }
}

class Son extends Fath {
    static {
        System.out.println("静态代码块Son");//4
    }

    {
        System.out.println("构造代码块Son");//7
    }

    public Son() {
        System.out.println("构造方法Son");//8
    }
}

public class Test {
    static {
        System.out.println("测试类的静态代码块1");//1
    }

    static {

        System.out.println("测试类的静态代码块2");//2
    }
    public static void main(String[] args) {
        Son son = new Son();
    }
}

注意点4

通过多态的形式去访问成员变量的时候 ,编译看左边,运行看左边
通过多态的形式去调用方法时 编译看左边,运行右边
通过多态的形式访问静态方法,编译左边,运行看左边

public class Fath {
    int num = 22;
    public static void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class Son extends Fath{
    int num = 44;
    public void sleep(){
        System.out.println("晚上睡");
    }
}

public class Test {
    public static void main(String[] args) {
        Fath s = new Son();
        System.out.println(s.num);//22
        s.sleep();//晚上睡
        s.eat();//吃饭
    }
}

注意点5

若看到一个方法的形参需要一个 类 类型，则我们需要传一个该类对象

public class A {
    int num = 4;
}

public class B extends A{
}

public class Test {
    public static void main(String[] args) {
        show(new B());//若看到一个方法的形参需要一个 类 类型，则我们需要传一个该类对象
    }
    public static void show(B b){
        System.out.println(b.num);
    }
}

注意点6

针对态的弊端:不能调用子类特有的方法
引出：向下转型
常见编译错误：类型转换异常

public class Fath {
    public void show() {
        System.out.println("父类一般方法");
    }
}

public class Son extends Fath {
    public void show() {
        System.out.println("子类重写父类方法");
    }

    public void showSon() {
        System.out.println("子类特有方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.show();
        son.showSon();

        Fath son1 = new Son();
        son1.show();
        //son1.showSon();//编译错误，多态不能调用子类特有的方法
        Son son2 = (Son) son1;//解决方法：向下转型
        son2.showSon();//向下转型后就可以用多态调用子类特有方法了
    }
}

类型转换异常
在上面代码的基础上加入Son2类和Test0类

public class Son2 extends Fath{
}

public class Test0 {
    public static void main(String[] args) {
        Fath son1 = new Son1();
        Son1 son11 = (Son1) son1;
        son1 = new Son2();//类型转换异常原因：不构成继承关系的类不能向下转型，如该例子，不构成继承关系的子类Son1和Son2，Son1不能向下转型为Son2
        Son2 son21 = (Son2) son1;//若无上一行语句，直接执行改行，则出现编译错误：ClassCastException 类型转换异常
    }
}