Java_面向对象的 static 和 abstract

static:表示静态的

　　static:可以用来修饰属性、方法、代码块（或初始化块）、内部类。

        一、static修饰属性（类变量）：

public class TestStatic {
    //static修饰属性
    private static int id;
    //static修饰方法
    public static void getId(){ System.out.println(id); }
    //static修饰代码块
    static{ System.out.println(id); }
    //static修饰内部类
    static class A{ private String name; }
}

　　　　1.由类创建的所有的对象，都共用这一个属性。

　　　　2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。 VS 实例变量 （非 static 修饰的属性，各个对象各自拥有一套副本）。

        A a1 = new A();
        a1.setId(1001);
        System.out.println(a1.getId());//a1输出为1001
        A a2 = new A();
        System.out.println(a2.getId());//a2输出也为1001
        System.out.println(a1.getId() == a2.getId());//输出为true

　　　　3.类变量随着类的加载而加载，而且单独一份。

　　　　4.静态的变量可以直接通过 “类.类变量” 的形式来调用。

　　　　5.类变量的加载要早于对象。所以当有对象以后，可以 “对象.类变量” 使用，但是 “类.实例变量” 是不行的。

public class TestStatic {
    public static void main(String[] args) {
        //"类.类变量" 调用
        System.out.println(A.id);
        // "对象.类变量" 调用
        A a1 = new A();
        System.out.println(a1.id);
    }
}
class A{
    public static int id = 1001;
    public static int getId() {    return id;    }
    public static void setId(int id) {    A.id = id;    }
}

　　　　6.类变量存在于静态域中。

        二、static修饰方法（类方法）：

　　　　1.随着类的加载而加载，在内存中也单独一份。

　　　　2.可以直接通过 “类.类方法” 的方式调用。

        //"类.类方法" 调用静态方法
        A.setId(1002);

　　　　3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性和方法。反之，非静态的方法是可以调用静态的属性和方法。

　　　　4.静态的方法内不可以有 this 或 super 关键字的！

class A{
    public static int id = 1001;
    private String name;
    
    public static int getId() {
        //test();                 静态方法不可以调用非静态的属性和方法
        //this.name = "小明";     静态的方法内不可以有 this 或 super 关键字的！
        return id;    
    }
    public void test(){
        //非静态的方法是可以调用静态的属性和方法
        A.id = 1002;
        getId();
    }
}

　　注：静态的结构（static 的属性、方法、代码块、内部类）的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构。

static 面试题：

public class TestStatic {
    public static void main(String[] args) {
        B b = new B();
        b.test();          //输出结果是什么？
    }
}

class A{
    static{
        System.out.println("A");
    }
    public A(){
        System.out.println("B");
    }
}

class B extends A{
    static{
        System.out.println("C");
    }
    public B(){
        System.out.println("D");
    }
    public void test(){
        System.out.println("E");
    }
}


//输出结果的顺序为：A ——> C ——> B ——> D ——> E

abstract:表示抽象的

　　abstract:可以用来修饰类和方法。

abstract class A{
    public abstract void test();
}

        一、abstract 修饰类：抽象类

　　　　1.不可被实例化。（不能 new)

　　　　2.抽象类有构造器 。（凡是类都有构造器）

　　　　3.抽象方法所在的类，一定是抽象类。

abstract class A{
    public abstract void test();
    public A(){}        //抽象类有构造器
}

　　　　4.抽象类中可以没有抽象方法。

abstract class K{
    public void test(){    System.out.println("抽象类中可以没有抽象方法"); }
}

　　　　5.当我们设计一个类，不需要创建此类的实体的时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就进行实例化。

         二、abstract 修饰方法：抽象方法

　　　　1.抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。

　　　　2.若子类继承抽象类，并重写了所有的抽象方法，则此类是一个 “实体类” ，既可以实例化。

　　　　3.若子类继承抽象类，但是没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的类。

public class TestAbstract {
    public static void main(String[] args) {
        //People p = new People();    抽象类不可被实例化
        Worker w = new Worker();
        w.show();
        w.test();
    }
}

abstract class People{
    public abstract void test();
    public abstract void show();
}

class Worker extends People{

    public Worker(){}
    @Override
    public void test() {
        System.out.println("重写 test() 方法");
    }

    @Override
    public void show() {
        System.out.println("重写 show() 方法");
    }    
}