java abstract static_Java_面向对象的 static 和 abstract

static:表示静态的

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

一、static修饰属性(类变量)：

public classTestStatic {//static修饰属性

private static intid;//static修饰方法

public static voidgetId(){ System.out.println(id); }//static修饰代码块

static{ System.out.println(id); }//static修饰内部类

static class A{ privateString name; }

}

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

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

A a1 = newA();

a1.setId(1001);

System.out.println(a1.getId());//a1输出为1001

A a2 = newA();

System.out.println(a2.getId());//a2输出也为1001

System.out.println(a1.getId() == a2.getId());//输出为true

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

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

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

public classTestStatic {public static voidmain(String[] args) {//"类.类变量" 调用

System.out.println(A.id);//"对象.类变量" 调用

A a1 = newA();

System.out.println(a1.id);

}

}classA{public static int id = 1001;public static int getId() { returnid; }public static void setId(int id) { A.id =id; }

}

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

二、static修饰方法(类方法)：

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

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

//"类.类方法" 调用静态方法

A.setId(1002);

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

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

classA{public static int id = 1001;privateString name;public static intgetId() {//test(); 静态方法不可以调用非静态的属性和方法//this.name = "小明"; 静态的方法内不可以有 this 或 super 关键字的！

returnid;

}public voidtest(){//非静态的方法是可以调用静态的属性和方法

A.id = 1002;

getId();

}

}

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

static 面试题：

public classTestStatic {public static voidmain(String[] args) {

B b= newB();

b.test();//输出结果是什么？

}

}classA{static{

System.out.println("A");

}publicA(){

System.out.println("B");

}

}class B extendsA{static{

System.out.println("C");

}publicB(){

System.out.println("D");

}public voidtest(){

System.out.println("E");

}

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

abstract:表示抽象的

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

abstract classA{public abstract voidtest();

}

一、abstract 修饰类：抽象类

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

2.抽象类有构造器 。(凡是类都有构造器)

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

abstract classA{public abstract voidtest();public A(){} //抽象类有构造器

}

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

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

}

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

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

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

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

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

public classTestAbstract {public static voidmain(String[] args) {//People p = new People(); 抽象类不可被实例化

Worker w = newWorker();

w.show();

w.test();

}

}abstract classPeople{public abstract voidtest();public abstract voidshow();

}class Worker extendsPeople{publicWorker(){}

@Overridepublic voidtest() {

System.out.println("重写 test() 方法");

}

@Overridepublic voidshow() {

System.out.println("重写 show() 方法");

}

}