static关键字+静态代码块+继承及Arrays

static关键字+静态代码块+继承及Arrays

一、static关键字

1.含义：静态的

2.作用：

1.静态属性

2.静态方法

3.静态代码

3.static属性

1.含义：该属性属于类属性，不属于任何的对象

2.静态变量的生命周期：

创建：类加载到方法区时，系统会扫描该类的静态变量，并把静态变量加载到静态区中

销毁：程序结束时销毁

3.应用场景：该类所有的对象都共享的变量，就使用静态属性

4.注意：static修饰属性，该属性属于类的属性，直接用类名调用

public class Test01 {
	 
	public static void main(String[] args) {
		
		A a1 = new A();
		A a2 = new A();
		
		a1.str1 = "aaa";
		a2.str1 = "bbb";
		System.out.println(a1.str1);//aaa
		System.out.println(a2.str1);//bbb
		
		//a1.str2 = "xxx";
		//a2.str2 = "yyy";
		//System.out.println(a1.str2);//yyy
		//System.out.println(a2.str2);//yyy
		
		A.str2 = "xxx";
		A.str2 = "yyy";
		System.out.println(A.str2);//yyy
		System.out.println(A.str2);//yyy
	}
}

public class A {
	//属性/全局变量：成员变量 和 静态变量
	
	//成员变量
	String str1;
	
	//静态变量
	static String str2;
}

二、Arrays工具类包

import com.qf.arrays.MyArrays;
public class Test01 {
	
	public static void main(String[] args) {
		int[] is = {35,81,18,25,9,10,11,12,13};
		
		//排序 - 9,10,11,12,13,18,25,35,81
		MyArrays.sort(is);
		
		//搜索 - (注意：必须先排序，再查找，因为底层使用的是二分法查找)
		//返回元素在数组中的下标;如果元素不在数组中则返回 -插入点-1
		int index = MyArrays.binarySearch(is,35);
		System.out.println("搜索元素的下标为：" + index);
		
		//拷贝数组/扩容数组 
		int[] newIs1 = MyArrays.copyOf(is,is.length*2);
		
		//拷贝数组(开始下标-包含，结束下标-不包含)
		int[] newIs2 = MyArrays.copyOfRange(newIs1,3,6);
		
		//替换
		MyArrays.fill(newIs2,888);
		
		//将数组转换为字符串
		String str = MyArrays.toString(newIs2);
		System.out.println(str);
	}
}

/**
  * 史上最牛逼的数组工具类
  * @author 高雷
  * @version 1.0
  */
public class MyArrays {
	/**
	 * 按照数字顺序排序指定的数组
	 * @param  a 按照数字顺序排列指定数组
	 */
	public static void sort(int[] a) {
		for (int i = 0; i < a.length-1; i++) {
			for (int j = 0; j < a.length-1-i; j++) {
				if (a[j] > a[j+1]) {
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
			
		}
	}
	
	/**
	 * 使用二叉搜索算法搜索指定的int数组的指定值。
	 * @param a 要搜索的数组 
	 * @param key 要搜索的值 
	 * @return 搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 
	 */
	public static int binarySearch(int[] a,int key) {
		
		int start = 0;
		int end = a.length-1;
		while (start <= end) {
			int mid = (start + end)/2;
			if (key > a[mid]) {
				start = mid +1;
			}else if(key < a[mid]){
				end = mid -1;
			}else{
				return mid;
			}
			
		}
		return - start-1;
	}
	
	/**
	 * 将指定的int值分配给指定的int数组的每个元素。
	 * @param a 要填充的数组 
	 * @param val 要存储在数组的所有元素中的值 
	 */
	public static void fill(int[] a,int val){
		for (int i = 0; i < a.length; i++) {
			a[i] = val;
		}
	}
	
	/**
	 * 将指定的int值分配给指定的int数组的指定范围的每个元素。 
	 * @param a 要填充的数组 
	 * @param fromIndex 要用指定值填充的第一个元素（包括）的索引 
	 * @param toIndex 要用指定值填充的最后一个元素（排除）的索引 
	 * @param val 要存储在数组的所有元素中的值 
	 */
	public static void fill(int[] a,int fromIndex,int toIndex,int val){
		for (int i = fromIndex; i < toIndex; i++) {
			a[i] = val;
		}
	}
	
	/**
	 * 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
	 * @param original 要复制的数组 
	 * @param newLength 要返回的副本的长度
	 * @return 原始数组的副本，被截断或用零填充以获得指定的长度
	 */
	public static int[] copyOf(int[] original,int newLength){
		int[] is = new int[newLength];
		for (int i = 0; i < original.length; i++) {
			is[i] = original[i];
		}
		return is;
	}
	
	/**
	 * 将指定数组的指定范围复制到新数组中。
	 * @param original 要复制的数组 
	 * @param from 要复制的范围的初始索引（包括）
	 * @param to 要复制的范围的最终索引，排他。 （该索引可能位于数组之外） 
	 * @return 一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
	 */
	public static int[] copyOfRange(int[] original, int from, int to){
		int[] is = new int[to-from];
		
		int index = 0;
		for (int i = from; i < to; i++) {
			is[index] = original[i];
			index++;
		}
		
		return is;
	}
	
	/**
	 * 返回指定数组的内容的字符串表示形式。
	 * @param a 要返回其字符串表示形式的数组 
	 * @return 一个字符串表示 a 
	 */
	public static String toString(int[] a){
		String str = "[";
		for (int i = 0; i < a.length; i++) {
			str += a[i];
			if (i != a.length-1) {
				str += ",";
			}
		}
		str += "]";
		return str;
	}
	
}

三、静态代码块

1.构造方法的应用场景：初始化成员变量和静态变量

2.代码块：很少用

3.静态代码块：初始化静态变量

4.静态代码块为什么不能操作成员变量：

因为静态代码块是类加载到方法区时调用的，这时对象还没有创建

public class Test01 {
	 
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new A();
	}
}

public class A {
	
	String str1;//成员属性
	static String str2;//静态属性
	
	//静态代码块：类加载到方法区时调用
	//只能初始化静态属性
	static{
		str2 = "用真心待人";
		System.out.println("A类的静态代码块--" + str2);
	}
	
	//代码块：创建对象时优先于构造方法调用
	//可以初始化成员属性和静态属性
	{
		str1 = "xxx";
		str2 = "yyy";
		System.out.println("A类的代码块" + str1 + "--" + str2);
	}
	
	//构造方法：创建对象时调用
	//可以初始化成员属性和静态属性
	public A(){
		str1 = "aaa";
		str2 = "bbb";
		System.out.println("A类的构造方法" + str1 + "--" + str2);
	}
}

四、继承

1.含义：子类继承父类的属性和方法

2.好处：解决代码的冗余

3.应用场景：分析多个类时发现，多个类有相同的属性和方法，就把相同的属性和方法抽取到父类中

需求：编写中国人和日本人的类

人类：

•    	属性：姓名、性别、年龄
  

•    	方法：吃饭饭、睡觉觉
  

中国人类 继承 人类：

•    	属性：身份证
  

•    	方法：打太极
  

日本人类 继承 人类：

•    	属性：年号
  

•    	方法：拍电影
  

public class Test01 {

		public static void main(String[] args) {
			
			Chinese c = new Chinese();
			
			//设置父类的属性
			c.name = "张三丰";
			c.sex = '男';
			c.age = 120;
			
			//设置子类的属性
			c.id = "123456789";
			
			//获取父类的属性
			System.out.println(c.name);
			System.out.println(c.sex);
			System.out.println(c.age);
			
			//获取子类的属性
			System.out.println(c.id);
			
			//调用父类的方法
			c.eat();
			c.sleep();
			
			//调用子类的方法
			c.playTaiji();
			System.out.println("----------------------------");
			
			Japanese j = new Japanese();
			
			//设置父类的属性
			j.name = "波多";
			j.sex = '女';
			j.age = 18;
			
			//设置子类的属性
			j.yearNum = "昭和";
			
			//获取子类的属性
			j.yearNum = "昭和";
			
			//获取父类的属性
			System.out.println(j.name);
			System.out.println(j.sex);
			System.out.println(j.age);
			
			//获取子类的属性
			System.out.println(j.yearNum);
			
			//调用父类的方法
			j.eat();
			j.sleep();
			
		    //调用子类的方法
			j.playVideo();
		}
}

//父类
public class Person {
	
	String name;
	char sex;
	int age;
	
	public void eat(){
		System.out.println("吃饭饭");
	}
	
	public void sleep(){
		System.out.println("睡觉觉");
	}
}

//            子类	      继承	   父类
public class Chinese extends Person {

		String id;
		
		public void playTaiji(){
			System.out.println("打太极");
		}
}

public class Japanese extends Person {

		String yearNum;
		
		public void playVideo(){
			System.out.println("拍视频");
		}
}