java+抽象类与static修饰区别_Java基础学习——static final 抽象类 接口

这段时间比较系统地学习了Java方面的基础知识，其实就是结束实习后来填坑的(我自己太菜了)

今天学习的是几个关键字以及抽象类和接口。

1、static

public class Test_1 {

public static void main(String args[]){

Man m1 = new Man("June",17);

m1.nation = "China";

m1.name = "Tom";

System.out.println(m1);

}

}

class Man{

String name = "June";

int age;

static String nation ;

public Man(String name,int age){

super();

this.name = name;

this.age = age;

// this.nation = "zhongguo";没作用，赋值后还是改了类变量的值。

}

public String toString(){

return "Man [name="+ name + ",age=" + age +",nation="+nation +"]";

}

}

static修饰的属性为类变量，可以直接通过类.变量的方式调用，一般的变量为实例变量，属于对象的变量，先有的对象才有的实例变量，存在于堆空间中。而类变量的话存在于静态域中，先早于类的产生，结束的时间也比类的时间要晚，所以被static修饰的变量的生命周期比较长，这也是一大弊端。

另外，非静态方法中也可以调用静态的属性。

其次就是两种使用static修饰的变量的方式

(1)饿汉式

//饿汉式

class Singleton{

private Singleton(){

}

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

}

(2)懒汉式

//懒汉式

class Singleton1{

private Singleton1(){

}

private static Singleton1 instance = null;

public static Singleton1 getInstance(){

if(instance == null){

instance = new Singleton1();

}

return instance;

}

}

一般使用饿汉式，懒汉式有一个弊端就是，可能会引发线程安全的问题。

最后是初始化块，也称为代码块，用{ }表示。

class Order{

private static int orderid = 1001;

private String ordername;

public Order(){

super();

}

public Order(int orderid,String ordername){

super();

this.orderid = orderid;

this.ordername = ordername;

}

//代码块:初始化块 用static进行修饰的是静态代码块，没被修饰的是非静态代码块。

//非静态代码块的执行要早于构造器。静态代码块就加载一次，它的加载早于非静态代码块。

{

orderid = 1002;

ordername = "aa";

}

static {

System.out.println("我是静态代码块");

orderid = 1000; //静态代码块中只能执行静态的结构。

}

public int getOrderid() {

return orderid;

}

public void setOrderid(int orderid) {

this.orderid = orderid;

}

public String getOrdername() {

return ordername;

}

public void setOrdername(String ordername) {

this.ordername = ordername;

}

@Override

public String toString() {

return "Order{" +"orderid=" + orderid +", ordername='" + ordername + '\'' +'}';

}

}

2、final

标记的类不能被继承，修饰的方法不能被重写，修饰的属性不可被更改，就是一个常量。

3、抽象类(abstract)

abstract class Creator{

abstract void breath();

}

//抽象方法所在的类一定是抽象类；抽象类中可以没有抽象方法。

//abrstrct不能修饰属性、构造器、private、final、static。

abstract class AbstructPerson extends Creator{ //抽象方法只保存方法的功能，具体的执行由抽象类的子类执行。

public void eat(){

System.out.println("eat");

}

public void walk(){

System.out.println("walk");

}

}

//若子类继承抽象类，并重写了所有的抽象方法，则此类可以实例化。

//若子类没有重写所有的抽象方法，则还存在抽象方法。

class Student extends AbstructPerson{

public void eat(){

System.out.println("eating");

}

public void walk(){

System.out.println("walking");

}

@Override

void breath() {

System.out.println("Breath");

}

}

抽象类是没有具体实例的父类，也有构造器，不可以被实例化，abstract不能用来修饰属性、构造器、private 、 final 、static。

4、接口

接口可以形象地认为是抽象方法和常量值的定义的集合。接口中只有抽象方法和常量。

/*

接口可以看成一个特殊的抽象类，是与类并行的一个概念。

接口没有构造器。接口定义的就是一种功能，此功能可以被类所实现。

实现接口的类，必须要重写其中的所有功能的抽象方法,否则就定义类为抽象的类即可。

接口与接口之间是继承关系，而且可以实现多继承。

类可以实现多个接口，类的继承是单继承。

*/

interface AA{

//常量，所有的常量都是用public static final修饰的，所以可以忽略不写。

public static final int I = 10;

public static final boolean Flag = false;

//所有的抽象方法都用public abstract修饰。

void method1();

void method2();

}

//抽象类

abstract class BB implements AA{

}

//重写接口中所有的抽象方法

class CC implements AA{

@Override

public void method1() {

}

@Override

public void method2() {

}

}

总结：终于分清楚了这几个容易混淆的概念，面试笔试中都会问到，static的作用，以及接口和抽象类的区别。原先准备面试笔试时也只是在网上查查机械地去记忆它。现在终于弄明白了，static修饰的属性是类变量，存在于静态域中。接口和抽象类也很好区分：接口和抽象类都不能被实例化，接口可以继承多个接口，可以实现多继承，但抽象类只能实现单继承。并且，接口中没有构造器，抽象类中有构造器。