java中的static、final与abstract

static的用法如下：

package com.yan.java1;
/*
 * static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类
 * 
 * static修饰属性（类变量）：
 * 1.由类创建的所有的对象，都共用这一个属性
 * 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量(非static修饰的属性，各个对象各自拥有一个副本)
 * 3.类变量随着类的加载而加载的，而且独一份。
 * 4.静态的变量可以直接通过"类.类变量"的形式来调用
 * 5.类变量的加载要早于对象，所以当有对象以后，可以"对象.类变量"使用，但是"类.实例变量"是不行的。
 * 6.类变量存在于静态域中。
 * 
 * static修饰方法(类方法)：
 * 1.随着类的加载而加载，在内存中也是独一份
 * 2.可以直接通过"类.类方法"  的方式调用
 * 3.内部可以调用静态的属性 或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法。
 *  >静态的方法内是不可以有this或super关键字的
 * 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要与晚于非静态的结构。
 */
public class TestSportsMan {
	public static void main(String[] args) {
		SportsMan s1 = new SportsMan("宗介",1);
		SportsMan s2 = new SportsMan("波妞",2);
		s1.name = "金鱼";
		s1.nation = "China";
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(SportsMan.nation);
//		SportsMan.show1();
		s1.show1();
		SportsMan.show();
		s1.show();
	}
}
class SportsMan{
	//实例变量（随着对象的创建而被加载的）
	String name;
	int age;
	//类变量
	static String nation;//出生早于对象
	public SportsMan(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "SportsMan [name=" + name + ", age=" + age + ", nation=" + nation + "]";
	}
	
	public void  show1(){
		System.out.println("age:"+this.age);
		System.out.println("nation:"+nation);
		info();
		System.out.println("我是一名来自于中国的运动员");
	}
	public static void  show(){
		System.out.println("nation:"+nation);
		info();
		//this.show1();
		//System.out.println("age:"+this.age);
		System.out.println("我是一名来自于中国的运动员");
	}
	public static void info(){
		System.out.println("我是静态的方法");
	}
	
}

final的用法如下：

package com.yan.java1;
/*
 * final：最终的，可以用来修饰类、属性、方法
 * 
 * 1.final修饰类：这个类不能被继承。如：String类、StringBuffer类、System类   
 * 
 * 2.final修饰方法：不能被重写，如：Object类的getClass()
 * 
 * 3.final修饰属性：此属性就是一个常量，一旦初始化后，不能再被赋值。习惯上，常量用大写字符表示。
 * 此常量在哪里赋值：1.此常量不能使用默认初始化 2.可以显示的赋值、代码块、构造器
 * 
 * 变量用static final修饰，全局常量
 * 
 */
public class TestFinal {
	public static void main(String[] args) {
		System.out.println(Math.PI);
	}
}
class D{
	final int I = 12;
	final double PI ;
	final String NAME;
	public void m1(){
		System.out.println(I);
		//I = 24;
	}
	{
		PI = 3.14;
	}
	public D(){
		NAME = "金鱼";
	}
	public D(String name){
		this();
		//NAME = name;
	}
}
/*class SubString extends String{
	
}*/
final class A{
	
}
/*class B extends A{
	
}*/
abstract class C{
	public final void method1(){
		System.out.println("method1");
	}
	public abstract void method2();
}
class E extends C{
//	public void method1(){
//		
//	}
	public void method2(){
		
	}
}

abstract的用法如下：

package com.yan.java1;
/*
 * abstract：抽象的，可以用来修饰类、方法
 * 
 * 1.abstract修饰类：抽象类
 * 	1)不可被实例化
 * 	2)抽象类有构造器(凡是类都有构造器)
 * 	3)抽象方法所在的类，一定是抽象类
 * 	4)抽象类中可以没有抽象方法
 * 	> 当我们设计一个类，不需要创建此类的实例的时候，就可以考虑将其设置为抽象类，由其子类实现这个类的抽象方法以后，进行实例化。
 * 
 * 2.abstract修饰方法：抽象方法
 * 	1)格式：没有方法体，包括{}，如：public abstract void walk();
 * 	2)抽象方法只保留了方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
 *  3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个“实体类”，即可以实例化
 *  4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！
 * 
 * abstract 不能用来修饰属性、构造器、private、final、static
 */
public class TestAbstract {
	public static void main(String[] args) {
		//Person p1 = new Person();
	}

}

abstract class Creator{
	abstract void breath();
}

abstract class Person extends Creator{
	String name;
	public abstract void eat();//只保留了功能
	public abstract void walk();
	public Person(){
		
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}
class Student extends Person{
	public void eat(){
		System.out.println("学生吃饭");
	}
	public void walk(){
		System.out.println("学生走路");
	}
	@Override
	void breath() {
		// TODO Auto-generated method stub
		System.out.println("学生不应该呼吸有雾霾的空气");
	}
}
abstract class Worker extends Person{
	public void eat(){
		System.out.println("工人吃饭");
	}
	
}