java学习---------------------------抽象类和多态

关于java的学习记录：

1.

/**
 * 1.抽象类必须要有子类
 * 2.抽象类的子类（子类不是抽象类）必须要覆写抽象类之中的全部抽象方法
 * 3.抽象类对象的实例化需要依靠子类完成，采用向上转型的方式处理
 * 由于 抽象类里面会存在一些属性，那么在抽象类之中一定会存在构造方法，为了
 * 属性的初始化
 * 抽象类不能够使用final定义，因为抽象类必须有子类
 * 外部抽象类不允许使用static声明，而内部抽象类允许使用static声明，使用
 * static声明的内部抽象就相当于是个外部抽象类，继承的时候，用外部类.内部类
 * 任何情况下，如果要执行类中的static方法，可以直接通过类名调用
 * 有些时候，由于抽象类只需要一个特定的系统子类操作，所以可以忽略掉外部子类

 */

public class Demo2 {

    public static void main(String[] args) {
//        A1.B2 ab=new X();//向上转型
//        ab.print();
        A1 a=A1.getInstance();
        a.print();
    }

}

abstract class A1{
    public abstract void print();
    private static class B1 extends A1{//内部抽象类子类
        public void print() {
            System.out.println("==================");
        }
    }
    //这样的设计在系统类库中会比较常见，目的：为用户隐藏不需要的子类
    //这个方法不收实例化对象的控制
    public static A1 getInstance() {
        return new B1();
    }
    

}

/**在类的构造完成之前，所有属性的内容都是其对应的数据类型的默认值，而子类
 * 构造执行之前 一定先执行父类构造
 *
 */
//abstract class A1{
//    public void fun() {//普通方法
//        System.out.println("存在有方法体的方法");
//    }
//    //抽象方法
//    public abstract void print();
//    //static定义的内部类属于外部类
//    static abstract class B2{
//        public abstract void print();
//    }
//}
//class B1 extends A1{
//    @Override
//    public void print() {//强制要求覆写的方法
//        System.out.println("B 覆写方法");
//    }
//}
//class X extends A1.B2{
//    public void print() {
//        System.out.println("***********");
//    }

//}

2.

/**
 * 多态性的依赖：方法的覆写
 * 多态性严格来讲有两种形式：
 * 方法的多态性：
 * |-方法的重载：同一个方法，会根据传入参数的类型及个数不同执行不同的方法体
 * |-方法的覆写：同一个方法，会根据子类的不同实现不同的功能
 * 对象的多态性：指的是发生在继承关系之中，子类和父类之间的转换问题
 * |-向上转型（自动完成）：父类 父类对象=子类实例；
 * |-向下转型（强制完成）：子类 子类对象=（子类）父类实例；
 */
/**
 * 1.开发之中尽量使用向上转型，以统一参数类型，同时只有发生了向上转型之后才可以发生
 * 向下转型
 * 2.子类尽量不要过多的扩充与父类无关的操作方法
 *90%情况下子类的方法要与父类的方法功能保持一致
 */
public class Demo1 {

    public static void main(String[] args) {
//        B b=new B();
//        b.print();//B public void print(){}
//        A a=new B();//向上转型
//        a.print();//B public void print(){}
//        B b=(B)a;
//        b.funB();
//        A a=new B();
//        B b=(B)a;//向下转型
//        b.print();//B public void print(){}
        A a=new B();
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        if(a instanceof B) {
            B b=(B)a;
            b.print();
        }
    }
/**
 * 向上转型：由于多有的子类对象实例都可以自动的向上转型，所以在于参数的
 * 统一上,参数统一之后，还可以调用子类覆写后的方法体，即：同一个方法针对于
 * 不同的子类可以有不同的实现
 * 向下转型：指的是父类要调用子类自己特殊的方法,所有的父类发生向上转型之后只
 * 能够看见父类自己定义的全部方法信息，看不见子类的特殊方法，于是此时就需要使用
 * 向下转型，将父类对象转为子类对象，这样就可以使用子类的特殊方法了
 * 对象 instanceof 类 返回boolean性
 * 如果某个对象是某个类的实例，返回true
 * 对于向下转型如果发生之前，一定要首先发生对象的向上转型，建立关系后才可以转型
 */
}
class A{
    public void print() {
        System.out.println("A public void print(){}");
    }
}
class B extends A{
    public void print() {
        System.out.println("B public void print(){}");
    }
    public void funB() {
        System.out.println("B 扩充方法");
    }
}
class C extends A{
    public void print() {
        System.out.println("C public void print(){}");
    }
    
}