Java 学习 Day13

Java 学习 Day13

一、static 关键字的使用

1. static：静态的
2. static 可以用来修饰：属性、方法、代码块、内部类
3. 使用static修饰属性：静态变量（或类变量）
   （1）属性，按是否使用static修饰，又分为：静态属性 VS 非静态属性（实例变量）
   ①实例变量: 我们创建了类的多个对象, 每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值得修改
   ②静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
   （2）static修饰属性的其他说明：
   ① 静态变量随着类的加载而加载，可以通过"类.静态变量"的方式进行调用。
   ② 静态变量的加载要早于对象的创建。
   ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
   ④在类和对象中对类变量和实例变量的调用情况如下：

•              类变量	             实例变量
  

•      类		  yes		               no
  

•      对象	  yes		              yes
  

（3）静态属性举例：System.out; Math.PI;

4. 使用static修饰方法：静态方法
   ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
   ②

•              静态方法	            非静态方法	
  

•      类		  yes		               no
  

•      对象	  yes		              yes
  

③ 静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5. static注意点：
   （1）在静态的方法内，不能使用this关键字、super关键字
   （2）关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

6. 开发中，如何确定一个属性是否要声明为static的？
   （1）属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
   （2）类中的常量也常常声明为static

7. 开发中，如何确定一个方法是否要声明为static的？
   （1）操作静态属性的方法，通常设置为static的
   （2）工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

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 = "张继科";
		
		c1.show();
		
		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 : " + 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(){
		
	}
}

例1：

//static关键字的应用
public class CircleTest {
	public static void main(String[] args) {
		
		Circle c1 = new Circle();
		
		Circle c2 = new Circle();
		
		Circle c3 = new Circle(3.4);
		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;//自动赋值
	private static int total;//记录创建的圆的个数
	private static int init = 1001;//static声明的属性被所有对象所共享,每创建一个圆，init自动加1赋给id
									//init自动生成，不要get，set方法，id自动赋值，不需要设置set
	
	public Circle(){
		id = init++;
		total++;
	}
	
	public Circle(double radius){
		this();
//		id = init++;
//		total++;
		this.radius = radius;
		
	}
	
	
	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;
	}

}

例2：自定义数组的工具类，使用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) {

		return getSum(arr) / arr.length;
	}

	//如下的两个同名方法构成了重载
	// 反转数组
	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 static 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 arr1;
	}

	// 数组排序
	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) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		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;//返回一个负数，表示没有找到
	}

}

public class ArrayUtilTest {
	public static void main(String[] args) {
		
//		ArrayUtil util = new ArrayUtil();
		int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
		int max = ArrayUtil.getMax(arr);
		System.out.println("最大值为：" + max);
		
		System.out.println("排序前：");
		ArrayUtil.print(arr);
		
		
		ArrayUtil.sort(arr);
		System.out.println("排序后：");
		ArrayUtil.print(arr);
		
//		System.out.println("查找：");
//		int index = util.getIndex(arr, -5);
//		if(index >= 0){
//			System.out.println("找到了，索引地址为：" + index);
//		}else{
//			System.out.println("未找到");
//		}
		
		
//		util.reverse(arr);
	}
}

例3：编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”，定义封装这些属性的方法。账号要自动生成。
编写主类，使用银行账户类，输入、输出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("qwerty",2000);
		
		Account.setInterestRate(0.012);
		Account.setMinMoney(100);
		
		System.out.println(acct1);
		System.out.println(acct2);
		
		System.out.println(acct1.getInterestRate());
		System.out.println(acct1.getMinMoney());
	}
	
}

二、单例设计模式

1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

2. 如何实现？
   饿汉式 vs 懒汉式

3. 区分饿汉式 和 懒汉式
   （1） 饿汉式：
   坏处：对象加载时间过长。
   好处：饿汉式是线程安全的
   （2） 懒汉式：
   好处：延迟对象的创建。
   目前的写法坏处：线程不安全。—>到多线程内容时，再修改

例1：饿汉式

public class SingletonTest1 {
	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;
	}

例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.声明当前类对象，没有初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		
		if(instance == null){//为避免每次都新造对象，对instance进行判断
			
			instance = new Order();
			
		}
		return instance;
	}
	
}

三、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{
		
	public static void main(String[] args) {
	
		for(int i = 0;i < args.length;i++){
			args[i] = "args_" + i;
			System.out.println(args[i]);
		}
		
	}
	
}

例：

public class MainDemo {
	
	public static void main(String[] args) {
		
		for(int i = 0;i < args.length;i++){
			System.out.println("*****" + args[i]);
			
			int num = Integer.parseInt(args[i]);
			System.out.println("#####" + num);
			
		}
		
	}
	
}

四、类的成员之四：代码块（或初始化块）

1. 代码块的作用：用来初始化类、对象

2. 代码块如果有修饰的话，只能用static

3. 分类：静态代码块 VS 非静态代码块

4. 静态代码块
   （1）内部可以有输出语句
   （2）随着类的加载而执行，而且只执行一次
   （3）作用：初始化类的信息
   （4）如果一个类中定义了多个静态代码块，则按照声明的先后顺序来执行
   （5）静态代码块的执行要优先于非静态代码块的执行
   （6）静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

5. 非静态代码块
   （1）内部可以有输出语句
   （2）随着对象的创建而执行
   （3）每创建一个对象，就执行一次非静态代码块
   （4）作用：可以在创建对象时，对对象的属性等进行初始化
   （5）如果一个类中定义了多个非静态代码块，则按照声明的先后顺序来执行
   （6）非静态代码块内可以调用静态的属性、静态的方法、或非静态的属性、非静态的方法
   （7）对属性可以赋值的位置
   ①默认初始化
   ②显式初始化
   ③构造器中初始化
   ④有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值
   ⑤在代码块中赋值
   执行的先后顺序：① - ② / ⑤ - ③ - ④

例1：

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

运行结果：

例2：

//总结：由父及子，静态先行
class Root{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root(){
		super();
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid(){
		super();
		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("123");
		System.out.println("Leaf的构造器");
	}
}
public class LeafTest{
	public static void main(String[] args){
		new Leaf(); 
		System.out.println();
		new Leaf();
	}
}

运行结果：

例3：

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) { // 由父及子 静态先行
		System.out.println("77777777777");
		System.out.println("************************");
		new Son();
		System.out.println("************************");
		new Son();
		System.out.println("************************");
		new Father();
	}

}

运行结果：

五、final关键字

1. final 可以用来修饰的结构：类、方法、变量
2. final 用来修饰一个类：此类不能被其他类继承。比如：String 类、System 类、StringBuffer 类
3. final 用来修饰方法：表明此方法不能被重写。比如：Object类中getClass（）；
4. final 用来修饰变量：此时的“变量”就被称为是一个常量
   （1）final 修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
   （2）final修饰局部变量：尤其使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。以后，就只能在方法体内使用此形参，但不能进行重新赋值。
   （3）static final 用来修饰属性：全局常量