Java面向对象:static关键字、单例设计模式、main()方法、代码块、final关键字

package com.atguigu.java1;

/*
 * static关键字的使用：
 * 1.static：静态的
 * 
 * 2.可以用来修饰属性、方法、代码块、内部类（不能修饰构造器！）
 * 
 * 3.static修饰属性:静态变量
 * 		3.1属性，按是否使用static修饰，分为静态属性  vs 非静态属性（实例变量）
 * 			实例变量（非静态属性）：我们创建了类的多个对象，每个对象都独立的拥有一套类中的实例变量（非静态属性），
 * 					当修改其中一个对象的非静态属性时不会导致类中其他对象的同样属性值的修改。
 * 			静态变量（静态属性）：我们创建了类的多个对象，多个对象都共享同一个静态变量，当通过某一个对象去
 * 					修改静态变量时，会导致其他对象调用此静态变量时是修改过的。
 * 
 * 		3.2static 修饰属性其他说明：
 * 				①静态变量随着类的加载而加载。可以通过  类.静态变量  的方法进行调用。
 * 				②静态变量的加载早于对象的创建，而实例变量是在创建对象之后或者之中加载的。
 * 				③由于类只会加载一次(为了提高效率，内存中会缓存一段时间)，则静态变量在内存中也只有一份：存在《方法区的静态域》中。
 * 		
 *     			 ④      类变量                      实例变量
 * 		    			  类       yes		   no
 *       				 对象     yes        yes
 *        
 * 		3.3静态属性举例：System.out;Math.PI;
 * 
 * 
 * 4.static修饰方法:静态方法  
 * 				  ①随着类的加载而加载，可以直接通过  类.方法  来进行调用(此时类加载，静态方法也已经加载)
 *                
 *                ②       静态方法    非静态方法方法
 *                   类           yes          no
 *                  对象         yes          yes
 *                
 *                ③ 静态方法中：可以调用静态方法和静态属性；(从生命周期角度可以看出来)
 *                  非静态方法：既可以调用非静态方法和非静态属性，又可以调用静态方法和静态属性；(从生命周期角度可以看出来)
 * 
 * 5.static在使用中的细节：
 * 		5.1在静态方法中，不能使用this关键字、更不能使用super关键字。（因为对象还没创建）
 * 		5.2关于静态属性和静态方法的使用，就从生命周期的角度去理解。
 * 
 * 6.在开发中，如何去确定一个属性是否要声明为static
 * 		>属性可以被多个对象所共享的，不会随着对象的不同而不同的。
 * 		>final关键字，类中的常量也常常声明为static类型
 * 
 *   在开发中，如何去确定一个方法是否要声明为static
 *     >操作静态属性的方法，通常设置为static的（生命周期一样）
 *     >工具类中的方法，习惯上声明为static的 Math、 Arrays、 Coolections
 *     
 */
public class StaticTest {
	public static void main(String[] args) {
		Chinese.nation = "中国";
		Chinese c1 = new Chinese();
		c1.name = "姚明";
		c1.age = 40;
		c1.nation = "CHN";
		Chinese c2 = new Chinese();
		c2.name = "马龙";
		c2.age = 30;
		c1.nation = "CHINA";
		System.out.println("******************");
		c1.show();
	}
}

class Chinese {
	String name;
	int age;
	static String nation;
	public void eat(){
		
	}


	public static void show() {
		System.out.println("hello");
//		eat();//错误的： 在静态方法中是不能调用非静态方法的，因为生命周期的原因
		System.out.println(Chinese.nation);//应该是Chinese来调用nation这个属性。
	}

}

package com.atguigu.java2;

/*
 * 单例设计模式：
 * 1.所谓的单例设计模式就是，采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
 * 
 * 2.如何实现？
 * 饿汉式  懒汉式
 * 
 * 3.区分饿汉式和懒汉式
 * 		饿汉式：
 * 			坏处：对象加载时间过长（一上来就加载了对象）
 * 			好处：饿汉式是线程安全的
 * 		懒汉式：
 * 			好处：延迟对象的创建
 * 目前写法的坏处：线程不安全。---->到多线程再修改
 */
public class Singleton {
	public static void main(String[] args) {
		// Bank b = new Bank();//就造不了了，只能在内部构造
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		System.out.println(bank1 == bank2);
	}
}

// 饿汉式
class Bank {
	// 1.私有化类的构造器
	private Bank() {

	}

	// 2.内部创建类的对象
	// 要求此对象也必须是静态的
	private static Bank instance = new Bank();// 定义了一个私有属性，本私有属性恰好是对象

	// 3.提供公共的静态的方法，返回类的对象，供外部调用
	public static Bank getInstance() {
		return instance;
	}

}

// 单例设计模式：饿汉式：线程安全，但是加载时加长
class Order1 {
	private Order1() {

	}

	private static Order1 instance = new Order1();

	public static Order1 getInstance() {
		return instance;
	}
}

// 懒汉式：用的使用再创建，节省内存，但是线程不安全
class Order2 {
	private Order2() {

	}

	private static Order2 instance;

	public static Order2 getInstance() {
		if (instance == null) {
			instance = new Order2();
			return instance;
		}
		return instance;
	}
}

 

package com.atguigu.java2;
/*
 * main()的使用说明：
 * 1.main()作为程序的入口
 * 2.main()方法也是一个普通的静态方法
 * 3.main()方法也可以作为我们与控制台交互的一种方式（之前，使用Scanner()）
 */
public class MainTest {
	public static void main(String[] args) {
		Main.main(new String[4523768]);
	}
}

class Main{
	
	public static void main(String[] args) {
		System.out.println(args.length);
	}
}

package com.atguigu.java3;

/*
 * 类的成员之四：代码块（或初始化块）
 * 
 * 1.代码块的作用：用来初始化类或者对象
 * 
 * 2.代码块如果有修饰的话，只能使用static修饰
 * 
 * 3.分类：静态代码块  vs 非静态代码块
 * 
 * 4.静态代码块：
 * 		>内部可以有输出语句
 * 		>随着类的加载而执行,而且只执行一次
 * 		>作用：初始化当前类的一些信息
 * 		>如果在一个类中定义了多个静态代码块，则按照声明的先后顺序执行
 * 		>静态代码块的执行要优先于非静态代码块的执行
 * >静态代码块只能调用静态的属性、静态的方法、不能调用非静态的结构
 * 
 * 
 * 5.非静态的代码块
 * 		>内部可以有输出语句
 * 		>随着对象的创建而执行
 * 		>每创建一个对象就执行一次非静态代码块
 * 		>作用：可以在创建对象时可以对对象的属性等进行初始化
 * 		>如果在一个类中定义了多个非静态代码块，则按照声名的先后顺序执行
 * >非静态代码块可以调用静态属性、静态方法、非静态属性、非静态方法
 * 
 * 		对类中的属性可以赋值的位置：
 * 			①默认初始化
 * 			②显式初始化 /⑤在代码块中赋值(看先后顺序)
 * 			③构造器中
 * 			④对象.方法的方式
 * 
 * 总结：由父及子，静态先行。
 * 
 */
public class BlockTest {
	public static void main(String[] args) {
		String desc = Person.desc;
		System.out.println(desc);
		Person p1 = new Person();
		Person p2 = new Person();
		System.out.println(p1.age);
	}
}

class Person {
	// 属性
	String name;
	int age;
	static String desc = "我是一个人";

	// 构造器
	public Person() {

	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	// 代码块
	// 静态代码块
	static {
		System.out.println("你好 static block2");
		desc = "我是一个爱学习的人";
	}
	static {
		System.out.println("你好 static block1");

	}
	// 非静态的代码块
	{
		System.out.println("你好  非 static block");
		age = 1;

	}

	// 方法
	public void eat() {
		System.out.println("吃饭");
	}

	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}

package com.atguigu.java3;
/*
 * final关键字的使用：最终的
 * 
 * 1.final可以用来修饰的结构：类 、方法 、变量
 * 
 * 2.final来修饰一个类:此类就不能被其他类所继承！
 * 						比如：String类 、System类、StringBuffer类
 * 
 * 3.final修饰一个方法：表明此方法不能被重写
 * 						比如：Object类中的getClass()
 * 
 * 4.final修饰一个变量：此时的“变量”也就变成了一个常量
 * 						4.1final修饰一个属性：可以考虑的位置有：显式初始化（所有对象的某一属性是一样的）、
 * 									代码块中初始化（不单单是一个值，还需要调用某些方法）、
 * 									构造器中初始化（所有对象的某一属性是不一样的）
 * 						4.2final 修饰局部变量：
 * 									尤其是使用final修饰形参时，表明此形参是一个常量。放我们调用此方法时，
 * 									给常量赋一个实参。一旦赋值以后，
 * 									在方法体内就只能使用此形参，但是不能进行重新赋值操作。
 * 
 * static final:用来修饰属性：全局常量
 * 			
 */

import com.atguigu.java2.MainDemo;

public class FinalTest {

	final int WIDTH = 10;
	final int LEET;
	final int LEET2;
	final int LEET3;
	{
		LEET = 1;
	}

	public void doWidth() {
		// width = 20;
	}

	public void show() {
		final int NUM = 10;// 常量，就不能再操作了
		// num += 20;
	}

	public void show(final int num) {
		// num = 20;//编译不通过
		System.out.println(num);
	}

	public FinalTest() {
		LEET3 = 3;
		LEET2 = 6;
	}

	public FinalTest(int n) {
		this();
	}

	public void setDown(int down) {
		// this.LEET3 = down;

	}

	public static void main(String[] args) {
		int num = 10;
		num = num + 5;
		FinalTest test = new FinalTest();
		test.show(10);

	}
}

class FinalA {
	public final void show() {

	}
}

class B extends FinalA {
	// public void show(){
	//
	// }
}