11.13第13天

/*
 * 一static修饰属性：静态变量
 * 		1.我们创建了类的多个对象，多个对象共享同一个静态变量
 * 		2.静态变量随着类的加载而加载，加载要早于对象的创建
 * 二static修饰方法：静态方法
 * 		随着类的加载而加载，可以通过”类.静态方法“的方式调用
 * 		静态方法中只能调用静态方法和属性
 * 三static注意：
 * 	不能调用this和super
 * 四
 * 		开发中如何确定一个属性是否声明为static
 * 		》属性是共享的不会随着对象不同而改变
 * 
 * 		开发中如何确定一个方法是否声明为static
 * 		》操作静态属性的方法
 * 		》工具类中的方法，
 * 五
 * 		静态代码块
 * 		>内部可以有输出语句
 * 		>随着类的加载而执行，而且只执行一次
 * 		>作用：初始化类的信息
 * 		>静态代码块的执行优先于非静态代码块
 * 		动态代码块
 * 		>内部可以有输出语句
 * 		>随着对象的创建而执行
 * 		>每创建一个对象就执行一次非静态代码快
 * 		>作用：可以在创建对象时，对对象的属性初始化
 * 六
 * 		final修饰的类不能被继承，修饰的方法不能被重写。
 * 		final修饰变量：变常量
 * 			修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量，
 * 				当我们调用此方法时，给常量形参赋一个实参，一旦赋值以后，
 * 				只能在方法体内使用此形参，但不能进行重新赋值。
 * 
 * 		static final 用来修饰属性：全局常量
 */
public class StaticTest {
	public static void main(String args[]) {
		Chinese c1=new Chinese();
		c1.name="小辉";
		Chinese c2=new Chinese();
		c2.name="小明";
		
		c1.nation="CHN";
		System.out.println(c2.nation);
		Chinese.show();
	}
}
class Chinese{
	String name;
	static String coloyr="黄色";
	static String nation;
	public static void show() {
		System.out.println("我是中国人");
	}
	//非static的代码块
	{
		System.out.println("hello");
	}
	//static的代码块
	static {
		System.out.println("hello,static");
		coloyr="我有点黑";
	}
}

/*单例设计模式：
 * 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
 *区分饿汉式和懒汉式
 *	饿汉式：
 *		好处：对象加载时间长。
 *		坏处：饿汉式是线程安全的
 *	懒汉式：
 *		好处：延迟对象的创建
 *		坏处：线程不安全
 */
public class SingletonTest {
	public static void main(String[] args) {
		Bank bank1=Bank.getInstance();
		Bank bank2=Bank.getInstance();
		System.out.println(bank1==bank2);
		
		Order order1=Order.getInstance();
		Order order2=Order.getInstance();
		System.out.println(order1==order2);
	}
}
//饿汉式实现
class Bank{
	private Bank() {//1.构造私有化的构造器
	}
	//2.内部创建类的对象
	private static Bank instance=new Bank();
	
	//3.提供公共方法，返回类的对象
	public static Bank getInstance() {
		return instance;
	}
}
//懒汉式实现
class Order{
	//1.构造私有化的构造器
	private Order() {
	}
	//2.声明当前类对象，没有初始化
	private static Order instance=null;
	//3.
	public static Order getInstance() {
		if(instance==null) {
			instance=new Order();
		}
		return instance;
	}
}

/*
 * abstract修饰类：抽象类
 * 	》不能实例化
 * 	》抽象类中一定有构造器，便于子类实例化的时候调用
 * abstract修饰方法：抽象方法
 * 	>抽象方法只有方法的声明，没有实体
 * 
 * 注意：abstract不能用来修饰：属性，构造器，私有方法，静态方法，final的方法和类
 */
public class AbstractTest {
	public static void main(String[] args) {
	
	}
}
abstract class Person{
	String name;
	public Person(){
		
	}
	public Person(String name) {
		
	}
	//抽象方法
	public abstract void eat();
	
	public void play() {
		System.out.println("人要娱乐");
	}
}

class Student extends Person{
	public Student(String name) {
		super(name);
	}
	public void eat() {
		System.out.println("学生要吃蛋白质");
	}
}