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

比眉伴天荒 2024-04-09 02:01 108阅读 0赞

## 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("拍视频");
    		}
    }