十【Java】面向对象 关键字static

目录

01 Static关键字

1.1 static 使用

1.2 代码举例

 1.3  类变量 vs 实例变量内存解析

 1.4  static 修饰方法 （静态方法）

 1.5 static 练习

 1.6  单例设计模式

1.6.1 饿汉式

1.6.2  懒汉式

1.6.3 单例模式优点和应用场景

1.7 main方法使用说明

02 类中的代码块

2.1 代码块代码举例

 

---

01 Static关键字

1.1 static 使用

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过 new 关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。

我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。

1.2 代码举例

/*
 * static 关键字的使用
 * 
 * 1.static:静态的。
 * 2.static 可以用来修饰:属性、方法、代码块、内部类。
 * 
 * 3.使用 static 修饰属性:静态变量(或类变量)。
 * 		3.1  属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)
 * 		   实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。
 * 				当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
 * 		   静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过静态变量去修改某一个变量时，会导致其他对象调用此静态变量时，是修改过的。

 * 		3.2 static 修饰属性的其他说明:
 * 			① 静态变量随着类的加载而加载（与类同时加载）。可以通过"类.静态变量"的方式进行调用。
               Chinese.nation = ""
 * 			② 静态变量的加载要早于对象的创建，类的加载遭遇对象的创建
 * 			③ 由于类只会加载一次，则静态变量在内存中也只会存在一次。存在方法区的静态域中。
 * 
 * 			④ 		类变量		实例变量(动态变量)
 * 			类		yes			no
 * 			对象		yes			yes
 * 
 * 		3.3 静态属性举例:System.out.Math.PI;
 *  
 */
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;
		c2.nation = "CHINA";
		
		System.out.println(c1.nation); 
		
		//编译不通过
//		Chinese.name = "张继科";
		
	}
}
//中国人
class Chinese{
	
	String name;
	int age;
	static String nation;  // 加载Chinese类的时候就同时加载了
}

 1.3  类变量 vs 实例变量内存解析

 1.4  static 修饰方法 （静态方法）

/* 
 * 4.使用 static 修饰方法:静态方法
 * 		① 随着类的加载而加载，可以通过"类.静态方法"的方式调用
 * 		② 			静态方法		非静态方法
 * 			类		yes			no
 * 			对象		yes			yes
 * 		③ 静态方法中，只能调用静态的方法或属性，不能用类方法调用动态方法Chinese.show();
 * 		  非静态的方法中，可以调用所有的方法或属性 c1.eat();c1.show();
 * 
 * 5.static 注意点:
 * 	 5.1  在静态的方法内，不能使用 this 关键字、super 关键字

 *   5.2 关于静态属性和静态方法的使用，从生命周期的角度去理解。
 *   
 * 6.开发中，如何确定一个属性是否需要声明 static 的？
 * 	 》 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
 * 	 》 类中的常量也常常声明为 static
 *   
 *   开发中，如何确定一个方法是否要声明为 static 的？
 *   》 操作静态属性的方法，通常设置为 static 的
 *   》 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections
 * 	 
 */
public class StaticTest {
	public static void main(String[] args) {
		
		Chinese.nation = "中国";
		
		Chinese c1 = new Chinese();
		
		//编译不通过
//		Chinese.name = "张继科";
		
		c1.eat();
		
		Chinese.show();
		//编译不通过
//		chinese.eat();
//		Chinese.info();
	}
}
//中国人
class Chinese{
	
	String name;
	int age;
	static String nation;
	
	public void eat(){
		System.out.println("中国人吃中餐");
		//调用非静态结构
		this.info();
		System.out.println("name : " + name);
		//调用静态结构
		walk();
		System.out.println("nation : " + Chinese.nation);
	}
	
	public static void show(){   // 静态结构
		System.out.println("我是一个中国人！");
//		eat();        // 不能调用非静态结构
//		name = "Tom";
		//可以调用静态的结构
		System.out.println(Chinese.nation);
		walk();
	}
	
	public void info(){
		System.out.println("name : " + name + ",age : " + age);
	}
	
	public static void walk(){
		
	}
}

ArraysUnility 优化（定义方法为static类型）

/*
 * 自定义数组工具类
 */
public class ArrayUtil {

	// 求数组的最大值
	public static int getMax(int[] arr) {
		int maxValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	// 求数组的最小值
	public static int getMin(int[] arr) {
		int minValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}

	// 求数组总和
	public static int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}

	// 求数组平均值
	public static int getAvg(int[] arr) {
		int avgValue = getSum(arr) / arr.length;
		return avgValue;
	}

	//如下两个同名方法构成重载
	// 反转数组
	public static void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}
	
	public void reverse(String[] arr){
		
	}

	// 复制数组
	public static int[] copy(int[] arr) {
		int[] arr1 = new int[arr.length];
		for (int i = 0; i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		return null;
	}

	// 数组排序
	public static void sort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
//					int temp = arr[j];
//					arr[j] = arr[j + 1];
//					arr[j + 1] = temp;
					//错误的：
//					swap(arr[j],arr[j+1]);
					
					swap(arr,j ,j+1);
				}
			}
		}
	}
	
	//错误的:交换数组中两个指定位置元素的值
//	public void swap(int i,int j){
//		int temp = i;
//		i = j;
//		j = temp;
//	}
	
	//正确的：
	private static void swap(int[] arr,int i,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// 遍历数组
	public static void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + ",");
		}
		System.out.println("]");
	}

	// 查找指定元素
	public static int getIndex(int[] arr, int dest) {
		//线性查找
		for (int i = 0; i < arr.length; i++) {

			if (dest==arr[i]) {
				return i;
			}

		}
		return -1;
	}

}

 CircleTest

//static 关键字的应用
public class CircleTest {
	public static void main(String[] args) {
		
		Circle c1 = new Circle();
		
		Circle c2 = new Circle();
		
		Circle c3 = new Circle();
		
		System.out.println("c1 的 ID:" + c1.getId());
		System.out.println("c2 的 ID:" + c2.getId());
		System.out.println("c3 的 ID:" + c3.getId());
		
		System.out.println("创建圆的个数: " + Circle.getTotal());
		
	}
	
}

class Circle{
	
	private double radius;
	private int id;	//需要自动赋值
	// 构造器
	public Circle(){
		id = init++;
		total++;
	}
	
	public Circle(double radius){
		this();  // 这里要加空参构造器，否则 id初始化为0；
		//或
//		id = init++;
//		total++;
		this.radius = radius;
	}
	
	private static int total;//记录创建圆的个数
	private static int init = 1001;//static 声明的属性被所有对象所共享
	
	public double findArea(){
		return 3.14 * radius * radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	public int getId() {
		return id;
	}

	public static int getTotal() {
		return total;
	}
	
}

 1.5 static 练习

/*
 * 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、
 * “利率”、“最小余额”，定义封装这些属性的方法。
 * 账号要自动生成。编写主类，使用银行账户类，输入、输出 3 个储户的上述信息。
 * 考虑：哪些属性可以设计成 static 属性。
 * 
 */
public class Account {
	
	private int id;	//账号
	private String pwd = "000000";	//密码
	private double balance; //存款余额
	
	private static double interestRate; //利率
	private static double minMoney = 1.0;  //最小余额
	private static int init = 1001;	//用于自动生成 id
	
	public Account(){	//账号自动生成
		id = init++;
	}
	
	public Account(String pwd,double balance){
		id = init++;
		this.pwd = pwd;
		this.balance = balance;
	}
	
	public String getPwd() {
		return pwd;
	}
	
	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
	
	public static double getInterestRate() {
		return interestRate;
	}
	
	public static void setInterestRate(double interestRate) {
		Account.interestRate = interestRate;
	}
	
	public static double getMinMoney() {
		return minMoney;
	}
	
	public static void setMinMoney(double minMoney) {
		Account.minMoney = minMoney;
	}
	
	public int getId() {
		return id;
	}
	
	public double getBalance() {
		return balance;
	}

	@Override
	public String toString() {
		return "Account [id=" + id + ", pwd=" + pwd + ", balance=" + balance + "]";
	}
	
}

测试

public class AccountTest {
	public static void main(String[] args) {
		
		Account acct1 = new Account();
		Account acct2 = new Account("123",2000);
		
		Account.setInterestRate(0.012); 
		Account.setMinMoney(100);
		
		System.out.println(acct1);  // 重写toString
		System.out.println(acct2);
		
		System.out.println(acct1.getInterestRate()); // 0.012
		System.out.println(acct1.getMinMoney()); //100
	}
}

 1.6  单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。**设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。

”套路”

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为 private，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例设计模式的代码举例

1.6.1 饿汉式

/*
 * 单例设计模式:
 * 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
 *  
 * 2.如何实现？
 *   饿汉式	VS	懒汉式
 * 
 */
public class SingletonTest {
	public static void main(String[] args) {
//		Bank bank1 = new Bank(); 
//		Bank bank2 = new Bank(); 
		
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		
		System.out.println(bank1 == bank2);
		
	}
}

//单例的饿汉式
class Bank{
	
	//1.私有化类的构造器，避免在类外构造实例
	private Bank(){
		
	}
	
	//2.内部创见类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象。
	public static Bank getInstance(){
		return instance;
	}
}

1.6.2  懒汉式

/*
 * 单例的懒汉式实现
 * 
 */
public class SingletonTest2 {
	public static void main(String[] args) {
		
		Order order1 = Order.getInstance();
		Order order2 = Order.getInstance();
		
		System.out.println(order1 == order2);
	}
}
class Order{
	//1.私有化类的构造器
	private Order(){
		
	}
	
	//2.声明当前类对象，没有初始化。
	//此对象也必须声明为 static 的
	private static Order instance = null;
	
	//3.声明 public、static 的返回当前类对象的方法
	public static Order getInstance(){
		if(instance == null){
			instance = new Order();		// 啥时候用啥时候造	
		}
		return instance;
	}
}

区分懒汉式和饿汉式
       饿汉式：坏处:对象加载时间过长。生命周期过长
               好处:饿汉式是线程安全的。
  
        懒汉式：好处:延迟对象的创建。
                 坏处:目前的写法，会线程不安全。---》到多线程内容时，再修改 

1.6.3 单例模式优点和应用场景

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

1.7 main方法使用说明

• 作为程序入口

• main（），普通的静态方法

• /*
   * main()方法的使用说明
   * 1.main()方法作为程序的入口;
   * 2.main()方法也是一个普通的静态方法
   * 3.main()方法也可以作为我们与控制台交互的方式。(之前，使用 Scanner)
   * 
   * 
   */
  public class MainTest {
  	public static void main(String[] args) {	//入口
  		
  		Main.main(new String[100]);
  		
  		MainTest test = new MainTest();
  		test.show();  // 调用动态必须先创建实例
  	}
  	
  	public void show(){ //非静态方法
  		
  	}
  }
  
  class Main{   //这里的main方法作为普通的静态方法
  	public static void main(String[] args) {
  		args = new String[100];
  		for(int i = 0;i < args.length;i++){
  			args[i] = "args_" + i;
  			System.out.println(args[i]);
  		}
  	}
  }
  

  02 类中的代码块

 * 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);
  		
  		Person.info();
  	}
  }
  
  class Person{
  	//属性
  	String name;
  	int age;
  	static String desc = "我是一个青年";
  	
  	//构造器
  	public Person(){
  		
  	}
  	
  	//static 的代码块
  	static{
  		System.out.println("hello,static block-1");
  		//调用静态结构
  		desc = "我是一个爱小说的人";
  		info();
  		//不能调用非静态结构
  //		eat();
  //		name = "Tom";
  	}
  	
  	static{
  		System.out.println("hello,static block-2");
  	}
  	
  	//非 static 的代码块
  	{
  		System.out.println("hello,block-2");
  	}
  	{
  		System.out.println("hello,block-1");
  		//调用非静态结构
  		age = 1;
  		eat();
  		//调用静态结构
  		desc = "我是一个爱小说的人 1";
  		info();
  	}	
  	
  	//方法
  	public Person(String name,int age){
  		this.name = name;
  		this.age = age;
  	}
  	
  	public void eat(){
  		System.out.println("吃饭");
  	}
  
  	@Override
  	public String toString() {
  		return "Person [name=" + name + ", age=" + age + "]";
  	}
  	public static void info(){
  		System.out.println("我是一个快乐的人。");
  	}
  	
  }
  

  2.1 代码块代码举例

• 举例一

//总结:由父类到子类，静态先行
/*
先运行父类到子类的静态代码块，表示三者都加载了；
非静态代码块执行先于构造器
*/
class Root{
	static{
		System.out.println("Root 的静态初始化块");
	}

	{
		System.out.println("Root 的普通初始化块");
	}

	public Root(){
		System.out.println("Root 的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid 的静态初始化块");
	}

	{
		System.out.println("Mid 的普通初始化块");
	}

	public Mid(){
		System.out.println("Mid 的无参数的构造器");
	}

	public Mid(String msg){
		//通过 this 调用同一类中重载的构造器
		this();
		System.out.println("Mid 的带参数构造器，其参数值："
			+ msg);
	}
}


class Leaf extends Mid{
	static{
		System.out.println("Leaf 的静态初始化块");
	}

	{
		System.out.println("Leaf 的普通初始化块");
	}

	public Leaf(){
		//通过 super 调用父类中有一个字符串参数的构造器
		super("尚硅谷");
		System.out.println("Leaf 的构造器");
	}
}


public class LeafTest{
	public static void main(String[] args){
		new Leaf();
        System.out.println("");
		new Leaf();
	}
}

输出结果：
 

Root 的静态初始化块
Mid 的静态初始化块
Leaf 的静态初始化块
Root 的普通初始化块
Root 的无参数的构造器
Mid 的普通初始化块
Mid 的无参数的构造器
Mid 的带参数构造器，其参数值：尚硅谷
Leaf 的普通初始化块
Leaf 的构造器

// 这里证明 静态代码块只运行一次
Root 的普通初始化块
Root 的无参数的构造器
Mid 的普通初始化块
Mid 的无参数的构造器
Mid 的带参数构造器，其参数值：尚硅谷
Leaf 的普通初始化块
Leaf 的构造器

 举例二

class Father {
	static {
		System.out.println("11111111111");
	}

	{
		System.out.println("22222222222");
	}

	public Father() {
		System.out.println("33333333333");

	}

}

public class Son extends Father {
	static {
		System.out.println("44444444444");
	}

	{
		System.out.println("55555555555");
	}

	public Son() {
		System.out.println("66666666666");
	}

	public static void main(String[] args) { // main方法也是静态方法，类的静态代码块会先执行                         
        由父及子 静态先行
		System.out.println("77777777777");
		System.out.println("************************");

		new Son();
		System.out.println("************************");

		new Son();
		System.out.println("************************");
		new Father();
	}

}

•  总结：程序中成员变量赋值的执行顺序

/*
 * 对属性可以赋值的位置:
 *  ①默认初始化
 *  ②显式初始化 / ⑤在代码块中赋值 （谁先写谁先执行）
 *  ③构造器中初始化
 *  ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
 *  
 *  执行的先后顺序:① - ② / ⑤ - ③ - ④
 */
public class OrderTest {
	public static void main(String[] args) {
		Order order = new Order();
		System.out.println(order.orderId); // 4
	}
}

class Order{
	
	int orderId = 3;
	{
		orderId = 4;
	}
	
}