static关键字,静态代码块,构造方法,构造代码块的优先级,继承

1.static关键字的特点

/*
1)static随着类的加载而加载
2)优先于对象存在,肯定不能this共存
3)能够被多个对象共用,共享
4)它的特殊访问方式:通过类名.变量名---->类变量(变量被static修饰的)
			    通过类名.方法名()--->类方法(方法被static修饰)
	*/

public class ArrayTool{//针对数组操作的工具类
    private ArrayTool(){} //构造方法私有化,目的:外界不能直接创建当前类的实例(对象)!
    
    //提供了一些静态功能
    public static void bubbleSort(int[] arr){
        for(int x = 0 ; x < arr.length-1 ; x ++){
            for(int y = 0 ; y < arr.length-1-x ; y ++){
                if(arr[y] > arr[y+1]){
                    int temp = arr[y] ;
                    arr[y] = arr[y+1] ;
                    arr[y+1] = temp ;
                }
            }
        }
    }
    
    //数组的遍历
    //数组的最值
    //查询元素...
}


//测试类
public class ArrayDemo{
    public static void main(String[] args){
        int[] arr = {89,67,56,97,13} ;
        //直接使用类名访问
        ArrayTool.bubbleSort(arr) ;
        //在遍历即可!
    }
}
			    
			 

2.静态代码块,构造方法,构造代码块的优先级

静态代码块 > 构造代码块 > 构造方法...
静态执行一次!

3.什么是继承,继承的好处是什么

继承:将多个类的共性内容抽取到一个独立的类中,让这多个类和独立的类之间产生一种关系:继承!
格式:
		class Fu{
				//将一些功能抽取到父类中
		}
		class Zi extends Fu{
		
		
		}
继承的好处:
	1)可以提高代码复用性
	2)提高的代码的维护下
	3)类与类之间产生的关系:是多态的前提条件!
		

4.继承的特点

特点:
	1)在Java语言中,类与类之间的关系,只支持单继承,不支持多继承!
	2)可以支持多层继承!
	
	class GrandFu{}
	class Fu extends GrandFu{}
	class Zi extends Fu{
	
	}

5.继承中:子类和父类的成员变量名称一致的情况,如何访问

1)先在子类的局部位置中找,是否存在这个变量名称,如果存在,就使用;
2)如果不存在,那么就在子类的成员位置中找是否存在,如果存在,就使用
3)如果不存在,那么在父类的成员位置中找是否存在,如果存在,就使用
4)如果不存在,那么久报错了,那说明没有这个变量...

6.继承中构造方法的访问:子类是如何访问父类的构造方法的
子类的所有的构造方法的第一句话:super(); 默认的
子类的所有构造方法间接访问父类的无参构造方法:
需要让父类先进行初始化,因为子类中可能会用到父类的数据!(分层初始化)!

/*
那么如果父类中没有无参构造方法,子类会怎样?如何解决

子类全部报错
方式1:可以通过手动给出无参构造方法
方式2:子类的所有构造方法的第一句话: 通过super(xxx):访问父类的有参构造方法
方式3:在子类的有参构造方法中的第一句话:this():来先访问本类的无参构造方法,然后再本类无参构造方法 第一话
		super(xxx):访问父类的有参构造方法,让父类进行初始化!
*/


/**
	开发中:子类中 无参构造访问父类的无参构造方法!
		  子类的有参构造方法访问父类的有参构造方法!
*/

class Fu{
    /*
    public Fu(){
        
    }
    */
    public Fu(int i){
        System.out.println("class Fu(int i)") ;
    }
}

class Zi extends Fu{
    public Zi(){
       // super(10) ; //子类访问父类的有参构造方法
        
        super(10) ;//本类的无参构造方法直接先访问父类的有参构造方法
        System.out.println("class Zi()") ;
    }
    
    public Zi(String str){
      //  super(10) ;//子类访问父类的有参构造
        
        this() ; //先访问本类的无参构造方法
        System.out.println("class Zi(String str)") ;
    }
}