Java自学课程笔记3

2021年1月30日10点17分
JAVA自学课程笔记3：
    
    static：
        静态成员属于类本身，不属于对象，被类的所有对象共有。不创建对象也可以使用。（类似于C的static变量）。

        静态成员不能访问非静态成员：
            class A{
                public int i = 10;
                static int j = 20;

                public static void f(){
                    i = 99    //error
                    j = 88    //OK
                }
            }
            
        获得引用对象次数:
            class A{
                private int i;
                private static int cnt = 0;

                public A(){
                    ++cnt;
                }

                public A(int i){
                    this.i = i;
                    ++cnt;
                }

                public static int getCnt(){
                    return this.cnt;
                }
            }

        只有静态非私有方法才可以通过类名的方法访问，System.out.print()方法中print()方法、System.arraycopy()方法中的arraycopy()方法就是静态非私有方法。
        
    继承（extends）:
        语法：class 子类（派生类） extends 父类（基类）。
        为多态创造条件。
        private成员不能被继承。但其在物理上被继承了过来，逻辑上程序员无法访问。因此有可能造成内存浪费。
        子类的普通方法中不能用super()调用父类的构造方法，要在子类的构造方法中才能调用。
        每个子类构造方法的第一条语句中，都是隐含地调用super()。
        当父类有多个构造函数时，super()只调用其中一个。
        方法重写：
            若一父类a中含有的方法f()被子类b继承了，同时在子类b中创建了同名的方法成员f()，则视为方法重写。
            且不能原先父类中的被覆盖的方法f()访问权限更严格（访问控制符等级不能下降）。
                如：原先父类a中为public void f()在子类b中重写不能重写为protected void f()。这是为了能使多态在任意情况下能实现（之后的内容）。

    多态（polymorphism：poly）：
        在继承的基础上，有子类和父类。子类可以赋值给父类，反过来不行，因为子类是父类的一种（子类可以当作父类看待）。
            class A{
            }
            
            class B extends A{
            }

            public class Test1{
                public static void main(String[] args){
                    B bb = new B();
                    A aa = new A();
                    aa = bb;
                }
            }

        且通过被赋值的父类引用只能访问子类从父类继承过来的成员，而不能访问子类特有的成员。
            class A{
                public void f(){}
            }

            class B extends A{
                public void f(){}
                public void g(){}
            }

            public class Test1{
                public static void main(String[] args){
                    B bb = new B();
                    A aa = new A();
                    aa = bb;
                    aa.f();        //OK
                    //aa.g();    //error
                }
            }

        相同系谱，不同对象，一个方法，不同结果。
            class A{
                public void f(){
                    System.out.println("AAA");
                }
            }

            class B extends A{
                public void f(){
                    System.out.println("BBB");
                }
            }

            public class Test2{
                public static void g(A aa){
                    aa.f();
                }
                public static void main(String[] args){
                    A aa = new A();
                    B bb = new B();
                    g(aa);
                    g(bb);
                }
            }
        //运行结果：
            AAA
            BBB

    抽象（abstract）
        没有方法体的方法叫做抽象方法，抽象方法要求末尾加分号，并定义为abstract。
        若一个类中出现了抽象的属性成员，那该类必须更改为抽象类。抽象类中可以包含非抽象成员。父类非抽象，子类可以是抽象的（无实际意义）。
        定义一个抽象父类后，要使非抽象子类能继承该父类，则子类必须实现父类中的抽象成员（必须重写父类的抽象成员，因为子类继承了父类的抽象方法而子类又非抽象类）。
            abstract class A{
                abstract public void f();
                int i = 3;
            }

            class B extends A{
                public void f(){
                }
            }

            public class Test3{
                public static void main(String[] args){
                }
            }
        定义一个抽象父类后，要使子类能继承该父类，则子类必须为抽象类。
            abstract class A{
                abstract public void f();
                int i = 3;
            }

            abstract class B extends A{
            }

            public class Test4{
                public static void main(String[] args){
                }
            }
        对于一个抽象类，仅可以定义其一个抽象类的引用，不能定义一个对象。
            abstract class A{
                abstract public void f();
                int i = 3;
            }

            class B extends A{
                public void f(){
                    System.out.println("BBBB");
                }
            }

            public class Test5{
                public static void main(String[] args){
                    //A aa = new A();    //error
                    B bb = new B();        //OK
                    bb.f();            //OK
                    A aa;            //OK
                }
            }
        运用多态的方法，可以把抽象类给变实现。
            abstract class A{
                abstract public void f();
                int i = 3;
            }

            class B extends A{
                public void f(){
                    System.out.println("BBBB");
                }
            }

            public class Test6{
                public static void main(String[] args){
                    //A aa = new A();    //error
                    B bb = new B();        //OK
                    bb.f();            //OK
                    A aa;            //OK
                    aa = bb;
                    aa.f();
                }
            }
        //输出结果：
            BBBB
            BBBB

    Final:
        final修饰类则表示该类不可被继承。
        final修饰的属性必须被赋值且只能赋一次值。final定义变量后，变量即为常变量，不可再次赋值（类似于C的const（n.）（constant adj.））。若想定义后赋值，则必须通过其类的构造方法。
            class A{
                final public int i;

                public A(int i){
                    this.i = i;
                }
            }

            public class Test7{
                public static void main(String[] args){
                    A aa = new A(63);
                    System.out.println(aa.i);
                }
            }
        但若是final变量被初始化了，则无法再进行赋值。
            class A{
                final public int i = 63;

                public A(int i){
                    //this.i = i;        //error
                }
            }

            public class Test8{
                public static void main(String[] args){
                    A aa = new A(63);
                    System.out.println(aa.i);
                }
            }
        final修饰的方法可以被继承，但不能被重写。