JavaSE-三个修饰符abstract，static和final

深藏阁楼爱情的钟 2022-11-10 14:20 166阅读 0赞

# 三个关键字 #

## abstract/static/final ##

## 一.抽象 ##

### 1.什么是抽象 ###

似是而非的，像却又不是；具备某种对象的特征，但不完整。

## 二.抽象类、抽象方法\* ##

### 2.1抽象类 ###

>            1.不能被实例化的类,需要加abstract修饰,叫做抽象类。

### 2.2抽象类的作用 ###

>      1.充当子类的模板，可被子类继承提供共性的属性和方法
> 
>      2.可声明为引用,更自然的使用多态

###  2.3抽象方法 ###

>                   1.抽象类中,有相关行为,无法具体实现,需加abstract修饰,叫做抽象方法,
> 
>                   **2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类**

### 代码块： ###

创建抽象类动物，使用子类继承，运行测试方法  （Animal，Dog，Cat和Test类）

public abstract class Animal {  //抽象类
    	public Animal() {}
    	//抽象方法
    	public abstract void bark(); 
        //非抽象方法
    	public void eat() {}   
    }
    
    //子类继承父类后(父类有bark的抽象方法)，报错了
    //方案1，子类需要重写父类的方法(Dog)
    //方案2. 将自身变为抽象，这样，可以交给自己的子类去完成
    
    class Dog extends Animal{
    	@Override
    	public void bark() {	
    		System.out.println("汪汪汪~~~叫");
    	}
    }
    
    abstract class Cat extends Animal{
    	
    }
    
    
    class Text{
    	public static void main(String[] args) {
    	//Cannot instantiate the type Animal	
    	//	 Animal a=new Animal();  
    	//被abstract修饰的类，抽象类不能实例化对象	 
    		 Animal animal = new Dog();    //多态用法
    		 animal.bark();
    	}
    }

## 三.静态属性 ##

### 3.1实例属性 ###

实例属性：是每个对象各自持有的独立空间（多份），对象单方面修改，不会影响其他对象。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ_size_16_color_FFFFFF_t_70][]

通过代码理解

class GirlFrend {
    	int age;  //成员属性
    }
    
    public class Test {
    	public static void main(String[] args) {
    		GirlFrend fengjie = new GirlFrend();
    		fengjie.age = 20;
    		
    		GirlFrend liuyifei = new GirlFrend();
    		liuyifei.age = 30;
    		
    		//实例化的两个对象,每个对象都拥有独立的成员属性
    		System.out.println(fengjie.age);  //20
    		System.out.println(liuyifei.age); //30
    	}
     
    }

### 3.2静态属性 ###

静态属性是整个类共同持有的共享空间（一份），任何对象修改，都会影响其他对象。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ_size_16_color_FFFFFF_t_70 1][]

通过代码理解

//static: 属于类,在类加载的时候进行加载,优先于对象, 每一个对象共享同一份静态属性
    class GirlFrend2 {
    	static int age;  //静态属性
    }
    
    public class Test2 {
    	public static void main(String[] args) {
    		GirlFrend2 fengjie = new GirlFrend2();
    		fengjie.age = 20;  
    		
    		GirlFrend2 liuyifei = new GirlFrend2();
    		//The static field GirlFrend2.age should be accessed in a static way
    		liuyifei.age = 30;  //应该通过类名来调静态属性: GirlFrend2.age
    		
    		//实例化的两个对象,每个对象都拥有独立的成员属性
    		System.out.println(fengjie.age);  //30
    		System.out.println(liuyifei.age); //30
    	}  
    }

### 3.3什么是静态 ###

概念：

>  *  静态（static）可以修饰属性和方法。
>  *  称为静态属性（类属性）、静态方法（类方法）。
>  *  静态成员是全类所有对象共享的成员。
>  *  在全类中只有一份，不因创建多个对象而产生多份。
>  *  不必创建对象，可直接通过类名访问

### 案例 ###

统计一个类的对象被创建了多少次

class MyClass{
    	static int count;  //统计创建次数
    	public MyClass() {
    		count++; 
    	}
    }
    public class Test3 {
    	public static void main(String[] args) {
    		new MyClass();
    		new MyClass();
    		new MyClass();
    		//每个对象只有同一份共享的静态属性
    		System.out.println(MyClass.count);
    	}
    }

## 四.静态方法 ##

### 4.1静态方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ_size_16_color_FFFFFF_t_70 2][]

代码块：

//静态方法:调用方式,通过类名去调用;  如果在本类中可以省略类名
    //应用场景: 用作工具类使用--在其他项目中也可以共享方法的实现
    
    public class Test {
    	public static void main(String[] args) {
    		int sum = MyTool.add(1,2); // 在本类中调用静态方法,可以省略类名
    		System.out.println(sum);
    		
    		//在实际应用中: 
    		int[] a = {9,5,2,7};
    		System.out.println("排序前:"+Arrays.toString(a));
    		//Arrays.sort(a);  //系统已经写好了静态方法的具体实现
    		MyTool.sort(a);  //自定义静态方法
    		System.out.println("排序后:"+Arrays.toString(a));
    	}
    }

### 4.2静态的特点 ###

>                   1.静态方法允许直接访问静态成员  
>                   2.静态方法不能直接访问非静态成员  
>               **    3.静态方法中不允许使用this或super关键字**  
>                   ***4.静态方法可以继承，不能重写，没有多态***

代码块：

class MyClass{
    	static int a;  //静态属性
    	int  b;    //成员属性
    	
    	public void test() {
    		System.out.println(a);  //成员方法中可以使用静态属性
    	}
    	
    	public static void test2() {
    		
    		System.out.println(a);  //在静态方法中可以使用静态属性
    		//Cannot make a static reference to the non-static field b
    		//System.out.println(b);  //在静态方法中不能使用非静态属性--加载时机问题
    		
    //		System.out.println(this);  //静态方法不能使用this--加载时机
    	}
    }
    
    class MyA extends MyClass{
    	//@Override
    	//public static void test2() {}  //静态方法不能重写
    }
    public class Test2 {
    	public static void main(String[] args) {
    		new MyA().test2();  //静态方法具有继承性
    	}
    }

### 4.3动态和静态代码块 ###

--------------------

静态代码块只执行一次，动态代码块随着实例化的次数而执行。

//代码块: 分为动态代码块和静态代码块
    
    class MyClass{
    	static int a = 3;
    	String field = "成员属性";
    	public MyClass(){
    		System.out.println("构造方法");
    	}
    	
    	{
    		System.out.println(field);
    		System.out.println("动态代码块");
    	}
    	
    	public static void test() {
    		System.out.println("调静态方法...");
    	}
    }
    
    class MySon extends MyClass{
    	
    }
    
    public class Test {
    	public static void main(String[] args){
    		new MyClass();  //实例化自身
    		System.out.println("=======>");
    		new MyClass();  //实例化两次,则会触发两次动态代码块
    		//new MySon();
    		//System.out.println(MyClass.a);
    		
    		//MyClass.test();  //调静态方法
    	}
    }

## 五.final ##

### 5.1final ###

> 概念：最后的，不可更改的。
> 
>  *  final可修饰的内容：
>  *  类（最终类）
>  *  方法（最终方法）
>  *  变量（最终变量）

***final和static绝配***

### 5.2final类 ###

>  *  final修饰类：此类不能被继承。
>  *  String、Math、System均为final修饰的类，不能被继承。
> 
>  *  final修饰方法：此方法不能被覆盖。
>  *  意为最终方法，不支持子类以覆盖的形式修改。

### 5.3 final变量 ###

final修饰变量：此变量值不能被改变（常量）。

### 5.4final修饰成员变量，局部变量 ###

final修饰成员变量

>  *          实例常量赋值时机:显示初始化,动态代码块,构造方法
>  *          静态常量赋值时机: 显示初始化和静态代码块

final修饰局部变量

>  *            基本类型变量: 该变量值不能被改变
>  *            引用类型变量: 地址不可改变

### 5.5案例 ###

/*final*/ class MyClass{
    	//The blank final field a may not have been initialized
    	final String a;  //final修饰属性,必须要初始化值
    	//final成员变量赋值方式: 1. 初始化   2. 动态代码块  3. 构造方法
    
    //	{
    //		a = "999";
    //	}
    	
    	public MyClass() {
    		a = "555";
    	}
    	//final静态变量赋值方式: 1. 初始化  2. 静态代码块
    	final static int b;  
    	static {
    		b = 9;
    	}
    	
    	public /*final*/ void test() {
    		
    	}
    	
    	int e;
    }
    //The type MySon cannot subclass the final class MyClass
    class MySon extends MyClass{//MyClass不能有子类
    	@Override
    	public void test() { //Cannot override the final method from MyClass
    		
    	}
    }
    public class Test {
    	public static void main(String[] args) {
    		//注意: final修饰的变量,都变为了常量
    		final int c = 6;  //修饰基本变量
    		//c = 9;
    		//MyClass.b = 999;
    		
    		//------------final修饰引用对象的特点:地址不能改变,但值可以改变------------------
    		final int[] d = {1,3,5};  //不能改变数组引用对象
    		//d = new int[] {2,4};
    		d[0] = 6;    //里面的内容可以改
    		
    		final MyClass class1 = new MyClass();
    		//class1 = new MyClass();
    		
    		class1.e = 8;
    	
    	}
    }

//静态常量的应用场景: 作为状态值使用(就是用于做判断)  static+final(绝配)
    //写法: 静态常量,往往都是大写,如果有多个单词,则用_拼接
    //好处: 可读性强, 可维护性强
    class MyValue{
    	static final int SEX_MAN = 1;
    	static final int SEX_WOMAN = 2;
    }
    
    public class Test2 {
    	public static void main(String[] args) {
    		int value = MyValue.SEX_MAN;
    		switch (value) {
    		case MyValue.SEX_MAN:
    			System.out.println("男人");
    			break;
    		case MyValue.SEX_WOMAN:
    			System.out.println("女人");
    			break;	
    		default:
    			break;
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ_size_16_color_FFFFFF_t_70]: /images/20221022/bf19b648c31e4d69b52c4bc6f91f2793.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ_size_16_color_FFFFFF_t_70 1]: /images/20221022/5f36a3c6985c48d09d466153fcfcbbd8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210318202234983.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F3cTE1MTgzNDY4NjQ=,size_16,color_FFFFFF,t_70