Java的static，final，代码块，内部类，抽象类，接口等

1 static关键字月final关键字

1.1 static

static表示静态。可以修饰属性，方法，代码块内部类等，总结如下：

	特点
修饰属性	①属于类，调用方式：类名.属性； ②属于所有对象的公共属性：对象.属性； ③类变量在类加载的时候就会加载，而且只有一份； ④类变量存储在静态域中； ⑤生命周期比成员变量长。
修饰方法	①在类加载的时候加载； ②调用：类名.方法()； ③static修饰的方法叫静态方法，静态方法只能调用静态成员，不能调用非静态成员；非静态方法可以调用静态方法也可以调用非静态方法； ④在static修饰的方法不能出现this或super关键字。
修饰代码块	①static修饰的代码块叫静态代码块，在类加载的时候自动执行，给类进行初始化，而且只执行一次； ②一个类中可以定义多个静态代码块，按顺序执行； ③静态代码块只能访问类的静态成员，而不允许访问实例成员。
修饰内部类	static修饰内部类。普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需先实例一个外部类。

1.2 final

final可以修饰属性，方法，类，总结如下：

	特点
修饰类（final class 类名{}）	表示该类是一个最终类，不能被继承
修饰方法（final 返回值类型方法名()）	表示该方法不能重写
修饰属性（final 属性类型属性名）	表示一个常量，常量一般用大写字母表示

给常量初始化：（1）显示初始化赋值 final 类型变量名 = 值；

（2）静态块 static{}

（3）构造块进行初始化 {}

（4）构造器进行初始化在构造器中赋值

2 代码块

定义：用大括号“｛｝”将多行代码封装在一起，形成一个独立的代码区，这就构成了代码块。

分类如下：

（1）普通代码块：方法的{} / if(){} / 在方法里面{局部代码块}

（2）构造代码块：{} 写在类中，在构造器前执行，创建一次对象就会调用一次（可多次执行）

（3）静态代码块：static{}在类加载时执行，而且只执行一次，会在构造器前执行

（4）同步代码块：在方法 synchronized（锁对象）{}

3 抽象类和抽象方法

概念：用abstract修饰的类就是抽象类（类的修饰符：final/abstract）。

抽象方法：用abstract修饰的方法就是抽象方法

特点：

（1）抽象类不能被实例化（不能直接创建对象），是用来继承的；

（2）抽象类中可以有构造器；

（3）抽象类中可以有抽象方法也可以有非抽象方法；

（4）抽象方法不能具体实现（即没有方法体）；

（5）有抽象方法的类一定是抽象类，抽象类不一定要有抽象方法；

（6）抽象方法必须被继承的子类重写（除非子类也是抽象类，可以不用重写父类的抽象方法；）

（7）final（不能继承的）和abstract（用来继承的）不能同时修饰一个类和类

public  class Test {public static void main(String[] args) {//Animal a = new Animal();
//		Animal a = new Dog("旺财",5,"公");
//		a.eat();Test t = new Test();t.manager(new Dog("旺旺",2,"公"));t.manager(new Cat("猫咪",3));}public void manager(Animal a) {a.eat();a.run();}
}
abstract class Animal{String name;int age;public Animal() {super();}public Animal(String name, int age) {super();this.name = name;this.age = age;}//吃public abstract void eat();public abstract void run();
//	public void show() {
//		System.out.println();
//	}}
class Dog extends Animal{String sex;public Dog(String name,int age,String sex) {super(name,age);this.sex = sex;}@Overridepublic void eat() {System.out.println("够吃骨头");}@Overridepublic void run() {}}
class Cat extends Animal{public Cat(String name,int age) {super(name,age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void run() {}}

。

（8）abstract与static（静态的），不能同时修饰一个方法。声明static说明可以直接用类名调用该方法；声明abstract说明需要子类重写该方法；如果同时声明static和abstract，用类名调用一个抽象方法肯定不行

4 接口

概念：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。

定义语法：访问权限修饰符 interface 接口｛｝

特点：

（1）接口也是一个特殊的抽象类(不可以直接实例化)，可以包含常量和抽象方法；

（2）还可以包含静态方法和默认方法（jdk1.8之后的特性）；

（3）接口不可以定义构造器；

（4）实现接口的类必须重写接口的非抽象方法；

（5）类可以实现（implements）多个接口（避免类的单继承不足问题）；

（6）接口是多继承（extends）的。

常量默认[public static final]
public static final int n=10;int m = 11;
抽象方法默认：[public abstract]
public abstract void show1();void show();//一下两个为jdk1.8的新特性
//静态方法 static void show2() {System.out.println("接口中的静态方法");}//实现接口子类去重写(对象)default void show3() {System.out.println("默认的方法");}

作用：接口就是一种实现功能（定义功能_方法），定义规范。

/*** @Description 定义USB接口 实现其功能 start() stop();* @author refuel* @version v1.0*/
public class Test {public static void main(String[] args) {//方式1 普通创建电脑对象调用Computer1 c = new Computer1();c.Work(new CardReader());//方式2 匿名类的对象USB u = new USB() {@Overridepublic void start() {System.out.println("匿名类的对象开始");}@Overridepublic void stop() {System.out.println("匿名类的对象结束");}};c.Work(u);//方式3 匿名类的匿名对象c.Work(new USB() {@Overridepublic void start() {System.out.println("匿名类的匿名对象结束");}@Overridepublic void stop() {System.out.println("匿名类的匿名对象结束");}});}
}
interface USB {void start();void stop();
}
class Printer implements USB{@Overridepublic void start() {System.out.println("打印机工作");}@Overridepublic void stop() {System.out.println("打印机停止工作");}}
class CardReader implements USB {@Overridepublic void start() {System.out.println("读卡器工作");}@Overridepublic void stop() {System.out.println("读卡器停止工作");}}
class Computer1 {public void Work(USB u) {u.start();u.stop();}
}

5 内部类

概念：允许一个类的定义位于另一个类的内部，前者为内部类，后者为外部类。

分类：

（1）成员内部类（类中）：①分为静态和非静态的成员内部类②定义在类的内部，方法外③四个权限修饰符，static、final、abstract可以其进行修饰④非静态成员内部类：1. 外部类外部类对象 = new 外部类（）； 2. 外部类.内部类内部类对象=外部类对象.new 内部类名（）；静态成员内部类：外部类.内部类名内部类对象 = new 外部类.内部类名（）；

（2）局部内部类：①局部内部类定义在方法中②定义局部内部类的方法一般有一个返回值（局部内部类的父类类型），返回局部内部类型的对象。

public class Test1 {public static void main(String[] args) {//原始方式实现输出产品的名称和颜色Product p = new RedPen();p.getColor();System.out.println(p.getName());//局部内部类实现输出产品的名称和颜色Test1 t = new Test1();t.getProduct().getColor();System.out.println(t.getProduct().getName());}public Product getProduct() {//局部内部类
//		class BlackPen implements Product {
//			@Override
//			public String getName() {
//				
//				return "黑笔";
//			}
//
//			@Override
//			public void getColor() {
//				System.out.println("黑色");
//			}			
//		}
//		return new BlackPen();//匿名内部类的匿名对象return new Product() {@Overridepublic String getName() {return "蓝笔";}@Overridepublic void getColor() {System.out.println("蓝色");}};}}interface Product {String getName();void getColor();
}
class RedPen implements Product {@Overridepublic String getName() {return "红笔";}@Overridepublic void getColor() {System.out.println("虹色");}}