类加载顺序、抽象类和接口的简述

1、类的加载顺序

父类 Animal

子类 Person

运行结果

/*
* 1：加载父类
* 2：父类产生自己的静态空间
*       执行输出静态块
* 3：加载子类
* 4：子类产生自己的静态空间
*       执行输出静态的块
* 5：new 对象 相当于默认调用了父类的构造方法 super();
* 6：所以先开辟父类的对象空间
* 7：加载父类的非静态成员
* 8：执行父类的一般块、方法、属性、构造方法
* 9：之后开辟子类的对象空间
* 10：执行子类的一般块、方法、属性、构造方法
* 11：将new的对象空间交给 person 变量存储
*/

2、抽象类

abstract 抽象的
    1：可以修饰方法
    	用 abstract 修饰符修饰的方法，只有方法的结构体 没有方法执行体，叫抽象方法
        public abstract void eat() ;

    2：修饰类
        用 abstract 修饰符修饰的类，叫做抽象类
        抽象类中不一定含有抽象方法，抽象方法需要放在 抽象类或这接口中
        普通的类中是不能含有抽象方法的
        
        public abstract class Animal {

            public abstract void eat() ;

            public void sleep(){
                System.out.println("动物随便睡");
            }
        }

3、抽象类的特征：

1：类里面有什么 成员
    属性、方法、块、构造方法 （除了方法中多了一个 abstract 修饰的抽象方法之外，其余的跟之前的一样，没啥区别）
    
2：类如何使用、创建对象
    抽象类含有构造方法，但是我们不能直接通过构造方法直接创建对象
    所以抽象类只能通过子类继承来用

【注意】为什么不让自身的抽象类调用构造方法创建对象？但还有构造方法？
        因为抽象类中含有 abstract 修饰的抽象方法，所以只有方法结构，却没有执行体，所以可以认为该方法不全，也就是该类不全，是一个残次品，所以虽然有构造方法却不能使用，但是能够让子类继承然后实现，该抽象方法。
    
3：类和类的关系：
    抽象类--- 可以 直接单继承---抽象类
    抽象类--- 可以 直接单继承---具体类 （用法通常不会出现）
    具体类--- 不能 直接单继承---抽象类 
【注意】（必须将抽象类的父类中的抽象方法具体化，或者子类也变成抽象类）
    

public abstract class Animal {

    public abstract void eat() ;

    public void sleep(){
        System.out.println("动物随便睡");
    }
}

-------------------------------------
    
public class Person extends Animal {

    public void eat() {
        System.out.println("人类吃饭讲究色香味俱全");
    }

    public void sleep() {
        System.out.println("人类睡在温馨的席梦思上");
    }
}

-------------------------------------------
public class Pig extends Animal {
    public void eat() {
        System.out.println("猪吃的是饲料");
    }

    public void sleep(){
        System.out.println("小猪睡在猪圈里");
    }
}

4、接口 interface

什么是接口：
    接口也是一个类的结构 ，只不过用 interface 修饰 ，替换了原来的 class，接口通常只是用来定义规则的。
    
1：接口中含有的成员：
    属性：不能含有一般的属性，只能含有公有的静态的常量
        public static final String name = "接口中的属性";
        public static final 这三个修饰符是默认的，通常不写
            
    方法：不能含有一般方法，只能含有 public 公有的抽象的方法
        （或者 JDK1.8之后的 default修饰的一般方法）
    
            public abstract void test1();
            public abstract String test2(int id);

            default void test3(){
            System.out.println("JDK 1.8之后，接口中的一般方法");
            }
            default int test4(String name){
                return Integer.parseInt(name);
            }

    块：不能含有一般的程序块，也不能含有 static 块
    构造方法：没有构造方法
        
2：使用接口 创建对象？
        不能创建对象，只能通过子类多实现 implements 来做事，
        public class A implements B,C,B {
            
        }

3：与别的类结构的关系
    抽象类---------可以 直接多实现----------接口
    具体类---------不可以 直接多实现----------接口
    （必须将接口中的抽象方法具体化实现，或者自身变成接口）
    接口----不能继承别的类的
    接口和接口之间的 叫多实现

/**
 * @author :小熊猫陈江一
 * @description: 接口的成员特征
 */
public interface TestInterface {
    public static final String name = "接口中的属性";

    public abstract void test1();
    public abstract String test2(int id);

    default void test3(){
        System.out.println("JDK 1.8之后，接口中的一般方法");
    }
    default int test4(String name){
       return Integer.parseInt(name);
    }
}

----------------------------------------------
public abstract class B implements TestInterface{

    public abstract void eat();

    public void study(){
        System.out.println("好好学习，天天向上");
    }
}

-------------------------------------------
public class A extends B implements TestInterface {

    @Override
    public void test1() {

    }

    @Override
    public String test2(int id) {
        return null;
    }

    @Override
    public void eat() {
        System.out.println("需要重写的内容");
    }

    @Override
    public void study() {
        super.study();
    }
}