Java笔记第九章：三个修饰符

一、abstract[抽象的]

1.可以修饰类;

 （1）被abstract修饰的类成为抽象类
 （2）语法：
     abstract class 类名{}
 （3）特点：抽象类可以声明引用，但是不能通过对象
 （4）注意：抽象类中可以定义属性、成员方法、构造方法

2.可以修饰方法：

 （1）被abstract修饰的方法称为抽象方法
 （2）语法：访问修饰符abstract返回值类型 方法名(形参);
      注意：访问修饰符和abstract没有先后的顺序
 （3）特点：抽象方法只有方法的声明部分，没有方法的实现
 （4）注意：抽象方法只能定义在抽象类中

3.抽象类可以定义子类：

 （1）语法：
     class 类名 extends 抽象类类名 {}
     abstract class类名 extends 抽象类类名{}
 （2）注意：如果子类不想定义为抽象类，则必须覆盖抽象的父类中所有的抽象方法

package demo;
public class Test1{
	public static void main(String[] args){
		MyClass mc=new Sub();
		mc.m1();
		mc.m2();
		mc.m3();
	}
}
//抽象类
abstract class MyClass{
	int value=5;
	public MyClass(){}
	public void m1(){
		System.out.println("成员方法...");
	}
	public abstract void m2();
	abstract public int m3();
}
//子类
class Sub extends MyClass{
	public void m2(){
		System.out.println("m2...方法的实现部分...");
	}
	public int m3(){
		System.out.println("m3...方法的实现部分...");
		return 5;
	}
}

二、static[静态的]

1.可修饰属性：

 （1）被static 修饰的属性称为静态属性、静态变量、类变量
 （2）语法：static 数据类型 变量名;
           static 数据类型 变量名 = 值;
 （3）特点：静态属性基于类而存在，和创建多少对象无关，所有的对象共享同一份
 （4）使用：
     a.可以通过 对象名.静态属性名
     b.可以直接通过 类名.静态属性名 -》建议

 

2.可以修饰方法

 （1）被static修饰的方法称为静态方法
 （2）语法：
    访问修饰符 static 返回值类型 方法名(形参){}
 （3）注意：访问修饰符 和 static之间没有先后顺序
 （4）使用：类名.静态方法名(实参);
 （5）静态方法中只能访问本类的静态成员
 （6）静态方法中不能使用 this/super关键字

 思考：System.out.println(); 实现原理？
      System : 类
      out :静态属性 -》 对象，被 static
      println: -》方法

package demo;
public class Test5{
	public static void main(String[] args){
		//System.out.println(MyClass.n);
		//System.out.println(MyClass.n);
		//System.out.println(MyClass.n);
		//System.out.println(MyClass.n);
		/*MyClass mc = new MyClass();
		MyClass mc2 = new MyClass();
		MyClass mc3 = new MyClass();
		System.out.println(MyClass.n);*/
		System.out.println(Sub.b);
		System.out.println(MyClass.n);
	}
}
class MyClass{
	int m = 1; // 成员变量
	static int n = 5; // 静态变量	
	static{
		System.out.println("静态代码块...类加载，父类");
		n = 100;
	}
	public MyClass(){
		System.out.println("构造方法...对象的创建");
	}
}
class Sub extends MyClass{
	static int a = 3;
	static int b=5;
	static {
		System.out.println("类加载...子类");
	}
	public Sub(){
		System.out.println("构造方法..子类对象的创建...");
	}
}

3.可以修饰代码块

 （1）被static修饰的代码块 称为静态代码块
 （2）语法：
    class 类名{
      static{}
    }
 （3）作用：在类加载的时候，按照和静态属性定义的先后顺序完成静态属性的初始化工作
 （4）类加载：当 jvm第一次使用一个类的时候，通过classpath找到对应的.class文件，对文件进行读取，读取该类的相关信息（包、类、父类、属性、方法、构造方法等），将读取到的信息保存到jvm内存中，一个类类加载只进行一次。
 （5）类加载的时机（什么叫第一次使用一个类）
    a.第一次访问该类的静态成员（静态属性、方法）
    b.第一次创建该类对象：
          先进行类加载，再完成对象的创建
    c.子类类加载，会导致其父类先类加载

三、final[最终的、最后的]

1.final可以修饰变量(局部变量、实例变量、静态变量)

 （1）被final修饰的变量作用范围内的常量
 （2）语法：final 数据类型 变量名;
      final 数据类型 变量名 = 值;
 （3）被final修饰的引用，存储的对象不允许改变

2.final可以修饰方法：被final修饰的方法能被子类继承，但是不能被覆盖

3.final可以修饰类：被final修饰的类不能被继承，没有子类

package demo;
public class Test6{
	public static void main(String[] args){
		final int a = 5;
		//a = 20;
		System.out.println(a);
		final MyClass mc = new MyClass();
		//mc = new MyClass();
		mc.m = 100;
		//mc.n = 200;
		System.out.println(mc.n);
		Sub s = new Sub();
		s.test();
	}
}
 class MyClass {
	int m = 1;
	final int n = 10;
	public final void test(){
		System.out.println("方法...");
	}
}
class Sub extends MyClass{
	/*public void test(){
		System.out.println("....");
	}*/
}