JavaSE_第九章:三个修饰符_开心se网-CSDN博客

本文链接：https://blog.csdn.net/YX_SYXS/article/details/115037519

JavaSE学习历程

第一章:Java初识
 第二章:Java语言基础
 第三章:选择结构与分支结构
 第四章:循环结构
 第五章:方法/函数
 第六章:数组
 第七章:面向对象
 第八章:三大特性

第九章:三个修饰符

1 abstract

1.1 抽象

概念:似是而非,像却又不是;具备某种对象的特征,但不完整
程序是用来模拟现实世界,解决现实问题的;现实世界中存在的都是"动物"具体的子类对象,并不存在"动物"对象,所以,Animal不应该被独立创建成对象.

public class TestAbstract{
	public static void main(String[] args){
		//Animal仅是一种会吃会睡的对象,再无其他行文,不够具体,不够完整.
		Animal a = new Animal();
	}
}
class Animal{
	String breed;
	int age;
	String sex;
	
	public Animal(){}
	
	public void eat(){
		System.out.println("动物在吃....");
	}
	
	public void sleep(){
		System.out.println("动物在睡....");
	}
}

1.2 抽象类

应用:abstract修饰类,称为抽象类,抽象类意为不够完整的类,不够具体的类,抽象类对象无法独立存在,即此类不能new对象,

public class TestAbstract{
	public static void main(String[] args){
	//	Animal a = new Animal();//Animal是抽象的,无法实例化
	}
}
abstract class Animal{
	String breed;
	int age;
	String sex;
	
	public Animal(){}
	
	public void eat(){
		System.out.println("动物在吃....");
	}
	
	public void sleep(){
		System.out.println("动物在睡....");
	}
}

1.3 抽象类的作用

作用:
1.可被子类继承,提供共性属性和方法.
2.可声明为引用,更自然的使用多态.
经验:
抽象父类.可作为子类的组成部分,依附于子类对象存在,由父类共性+子类独有组成完整的子类对象

2 抽象方法

概念:不该被实现的方法—>
现象:animal父类提供的方法(吃,睡)很难满足子类的不同需求,如不定义,则表示所有动物不会吃,睡;如定义,略显多余,多数会被子类覆盖.
总结:方法声明必要,方法实现多余.

被abstract修饰的方法,被称为抽象方法,只有方法的声明,没有方法的实现({}部分).意为不完整的方法,必须包含在抽象类中.
产生继承关系后,子类必须重写父类中所有的抽象方法,否则子类还是抽象类.

抽象总结

abstract修饰类:不能new对象,但可以声明引用
abstract修饰方法:只有方法的声明,没有方法的实现({}部分),且必须包含在抽象类中
抽象类中不一定有抽象方法,但有抽象方法的类一定是抽象类
子类继承抽象类后,必须重写父类中所有的抽象方法,否则子类还是抽象类

3 static

3.1 实例属性

在这里插入图片描述

实例属性是每个对象各自持有的独立空间(多份),对象单方面修改,不会影响其它对象.

3.2 静态属性

在这里插入图片描述

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

3.3 静态

概念：

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

4 静态成员、类加载

4.1 静态方法

在这里插入图片描述

4.2 静态的特点

静态方法允许直接访问静态成员。
静态方法不能直接访问非静态成员。
静态方法中不允许使用this或是super关键字。
静态方法可以继承，不能重写、没有多态。

4.3 代码块

4.3.1 动态代码块

public class TestDynamicBlock{
	public static void main(String[] args){
		new MyClass();
	}
}

class MyClass{
	String field = "实例属性";
	
	/*动态代码块--->创建对象时,触发动态代码块的执行.
	执行地位:初始化属性之后,构造方法代码之前.
	作用:可为实例化属性赋值,或必要的初始行为.*/
	{
		System.out.println(field);
		System.out.println("动态代码块");
	}
	
	public MyClass(){
		System.out.println("构造方法");
	}
}

运行结果:
实例属性
动态代码块
构造方法

4.3.2 静态代码块

public class TestStaticBlock{
	public static void main(String[] args){
		MyClass.method();
	}
}

class MyClass{
	static String sField = "静态属性";
	/*
		类加载时,触发静态代码块的执行(仅一次)
		执行地位:静态属性初始化之后
		作用:可为静态属性赋值,或必要的初始化行为
	*/
	static{
		System.out.println(sField);
		System.out.println("静态代码块");
	}
	
	public static void method(){
		//无代码,只为触发静态属性的初始化和静态代码块的执行
	}
}

运行结果:
静态属性
静态代码块

注:方法只有被调用才会被执行.

4.4 类加载

JVM首次使用某个类时，需通过CLASSPATH查找该类的.class文件。

将.class文件中对类的描述信息加载到内存中，进行保存。
如：包名、类名、父类、属性、方法、构造方法…

加载时机：
创建对象。
创建子类对象。
访问静态属性。
调用静态方法。
主动加载：Class.forName(“全限定名”);

4.5 静态成员与动态成员加载顺序

动态成员在静态成员变量前加载
静态代码块属于静态成员,在类加载时初始化;假如有多个静态成员,则会按照编写的顺序执行.
动态代码块(每次构建对象都会执行),且先于构造方法执行.

public class Main {

    public static void main(String[] args) {
        Main.Func();   //10
    }

    int a = 10;      //4
    static int b = 11;//1

    static Main main = new Main();//2     //8

    //属于静态成员，静态代码块在类加载时可以初始化，假如有多个静态成员，则会按照编写的顺序执行
    static {
        System.out.println(11);    //9
    }

    {//实例代码块（每次构建对象都会执行）
        //实例代码块，每次生成类实例都会执行，并且，实例代码块的执行优先于构造器
        System.out.println(2);//5
    }

    public Main() {    //3
        System.out.println(3);   //6
        System.out.println(String.format("a=%d,b=%d", a, b));     //7
    }

    public static void Func() {
        System.out.println(4);   //11
    }

}

/*
运行结果:
2
3
a=10,b=11
11
4
*/