Java继承与多态详解及实例演示-优快云博客

继承中访问成员的特点：
构造方法：

super():调用父类的有参构造
super(有参数):调用父类的有参构造
this()：调用当前类的无参构造
this(有参数)：调用当前类的有参构造
this和super调用有参构造，必须写在构造方法的第一行

public class Demo01 {
    public static void main(String[] args) {
        Boo b=new Boo();
    }
}
class Aoo{
    int age;
    public  Aoo(int age){
        this.age=age;
        System.out.println("123456");
    }
    public Aoo(){
        this(0);
        System.out.println("Aoo的构造");
    }
}

/*
 Boo会不会自动补充无参构造? Boo中没有手动田间构造方法,所以会补充无参构造
 Boo会不会调用Aoo的构造方法?
 子类是需要使用父类的属性,父类中属性初始化是在父类的构造方法中完成,所以会调用父类的构造
 当没有使用super关键手动调用构造的时候,父类的构造调用吗?
 默认调用父类的无参构造
 得出结论:
    若父类没有无参构造,子类会报错
 解决办法:
    1.在子类构造方法中手动调用有参构造
    2.在父类中添加一个无参构造
 */
class Boo extends Aoo{
    public Boo(){
        super(20);
        System.out.println("Boo的构造"+age);
    }
}

重载(overload)和重写的区别(override)
发生位置:重载发生在同一个类中 ,重写发生在父子类中
方法的定义:重载只要方法名相同,参数列表不同,就发生重载,不考虑其他因素,重写两同两小一大
多态:

一个事务表现多种形态
一个人的多重身份

多态需要满足的前提条件:

要有继承或实现(接口)关系
要用方法的重写
要有父类型接受子类对象

public class Demo03 {
    public static void main(String[] args) {
        //多态
        //父类型接受子类对象(向上造型)
        Person p=new Mom();//小孩扮成大人
        p.sleep();//调用的还是子类,因为发生了重写
        /*
        一看:通过p可以调用什么,要看p前面的类型(要看他扮成了什么)
        二看:当调用的方法在子类中发生了重写,p在调用重写方法时,需要看new的对象
         */

        Mom m=new Mom();
        m.eat();//调用子类特有的方法去执行
    }
}
class Person{
    String name;
    int age;
    public Person(){

    }
    public Person(String name,int age) {
        this.name = name;
    }
    public void sleep(){
        System.out.println("一个人在看书");
    }
}
class Wife extends Person{
    public void sleep(){
        System.out.println("人和老公在一起");
    }
}
class Teacher extends Person{
    public void sleep(){
        System.out.println("老师在学校教学");
    }
}
class Mom extends Person{
    public void sleep(){
        System.out.println("人和小孩在一起玩耍");
    }
    public void eat(){
        System.out.println("正在给小孩一起吃饭");
    }
}

多态的示例:

public class Demo04 {
    public static void main(String[] args) {
        //Box b=new Box()
        // test(b);   ==test(new Box());

       // test(new Cox());
        Aox a=new Box();
        test(a);
    }
//    public static  void test(Box b){
//        System.out.println("test(new Box()");
//       b.sleep();
//    }
//    public static void test(Cox c){
//        System.out.println("test(new Cox()");
//       c.sleep();
//    }
    public static  void test(Aox a){
        System.out.println("test(Aox)");
        a.sleep();
    }
}
class Aox{
    public void sleep(){
        System.out.println("A在睡觉");
    }
}
class Box extends  Aox{
    public void sleep(){
        System.out.println("B在睡觉");
    }
//    public Box(){
//        System.out.println("Box");
//    }
}
class Cox extends Aox{

}

基本类型数组
基本类型[] 数组名=new 基本类型[数组长度]
引用类型数组
语法格式
引用类型[] 数组名=new 引用类型[数组长度]
只能放本类和子类

想定义一个数组
这个数组可以放A 也可以放B 还可以放C 还可以放D


public class demo05 {
    public static void main(String[] args) {
        //基本数据类型
        int[] arr=new int[10];
        //引用类型
        Aox[] bs=new Aox[2];
        //Aox bs[0]=new Box();  向上造型
        //父类型的引用指向子类型对象
        bs[0]=new Box();
        bs[1]=new Cox();//向上造型
        bs[2]=new Dox();

        System.out.println(bs[0]);
        System.out.println(bs[1]);
    }
}

class Aox{
    public void sleep(){
        System.out.println("A在睡觉");
    }
}
class Box extends  Aox{
    public void sleep(){
        System.out.println("B在睡觉");
    }
//    public Box(){
//        System.out.println("Box");
//    }
}
class Cox extends Aox{

}
class  Dox extends Aox{
    
}

java学习第14天