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() 方法");
    }    
}