11 三大修饰符

三大修饰符

abstract 抽象的

抽象的：就是只能描绘一个大概的概念

抽象类：用abstract修饰的类叫做抽象类 
	语法：
	abstract  class 类名{}
	
抽象方法：用abstract修饰的方法叫做抽象方法
	语法：
	访问修饰符 abstract 返回值类型  方法名(形参列表);
	abstract 访问修饰符 返回值类型  方法名(形参列表);
关于抽象方法和抽象类的特点：
	1.当一个类中有抽象方法时，那么这个类一定是抽象类
	2.一个抽象类中可以定义非抽象的方法
	3.抽象类不能通过手动创建对象的 但是可以声明引用
	4.抽象类的对象是存在的 但是不能手动创建 只能通过创建子类对象的时候由jvm创建子类对象之前创建抽象类对象
	5.当一个类继承了一个抽象类 如果这个类不想成为抽象类 那么这个类必须实现抽象类中所有的抽象方法
	
抽象类的好处： 强制使用多态  （一个类一旦继承抽象类 那么必须实现抽象类中所有的抽象方法 在运行时 调用的是子类覆盖抽象类中所有抽象的方法 强制实现了运行时多态）


案例：

public class Demo{
	public static void main(String[] args) {
		//Circle c = new Circle();
	}
	
}

abstract class Shape{
	//面积
	public abstract double area();
	//周长
	abstract public double girth();

	public void m() {
		System.out.println("我是方法m");
	}
	public  Shape() {
		System.out.println("抽象类的构造方法被调用");
		
	}

}

class Circle extends Shape{
	//面积
	public double area(){
		return 3;
	}
	//周长
	/*public double girth(){
		return 4;
	}*/
	//重写
	//面积
	/*public double area() {
		return Math.PI*r*r;
	}
	//周长
	public double girth() {
		return Math.PI*2*r;
	}*/
}

static 静态的

static修饰成员变量

static修饰的成员变量：类变量  静态变量  静态属性
语法：
访问修饰符 static  数据类型  变量名 = 变量值；
static 访问修饰符  数据类型  变量名 = 变量值；
特点：
	1.所有的对象共享类变量（静态变量）
	2.类变量可以通过 类名.属性名 访问  也可以通过创建对象用引用访问（不建议）
	3.类变量也有默认值和成员变量一样
成员变量（实例变量和静态变量）

注意：static不能修饰局部变量
案例：

public class Demo{
	public static void main(String[] args) {	
		Student s = new Student();
		System.out.println(s.a);
		//System.out.println(s.b);
		System.out.println(Student.b);

	}
	
}

class Student{
	//成员变量
	int a;
	//类变量
	static int b;

	//成员方法
	public void m1() {
		System.out.println(a);
		System.out.println(b);
	}	
	
}

static修饰成员方法

static修饰的成员方法： 静态方法 类方法
语法：
访问修饰符  static  返回值类型  方法名(形参列表){}
static 访问修饰符  返回值类型  方法名(形参列表){}
例如：
//静态方法
	public static void m2() {
		
	}
特点：
	1.静态方法可以通过  类名.方法名() 调用 ,也可以通过创建对象用引用去调用（不建议）
	2.静态方法中不可以直接访问 非静态的成员(成员变量 成员方法)，但是如果非要访问非静态的成员 必须创建当前类的对象进行访问
	3.静态方法只能被静态方法覆盖，并且没有多态(在运行时执行的是引用类型中所对应的静态方法 而不是子类覆盖后的静态方法)
    4.在静态方法中不能使用 this/super (因为this、super 都是和对象有关的 静态的成员属于类 类的创建先于对象的创建)
    
案例1:说明 静态方法的访问方式

public class Demo{
	public static void main(String[] args) {	
		//1.通过创建对象 用引用访问
		Student s1 = new Student();
		s1.m1();
		//s1.m2();

		//2.静态方法可以通过类名.方法名
		Student.m2();
		
	}
	
}

class Student{

	//成员方法
	public void m1() {
		System.out.println("成员方法被调用");
		
	}

	//静态方法
	public static void m2() {
		System.out.println("静态方法被调用");
		
	}

}


案例2：说明静态方法不可以直接访问非静态的成员


public class Demo{
	public static void main(String[] args) {	
		//1.通过创建对象 用引用访问
		Student s1 = new Student();
		s1.m1();
		//s1.m2();

		//2.静态方法可以通过类名.方法名
		Student.m2();
		
	}
	
}

class Student{
	//成员变量
	int a;
	//静态变量
	static int b;

	
	//成员方法
	public void m1() {
		System.out.println("成员方法被调用");
		
	}

	//静态方法
	public static void m2() {
		//System.out.println(a);//成员变量  不可以
		System.out.println(b);//静态变量  
		m1();
		System.out.println("静态方法被调用");
		
	}

}

案例3：非要访问非静态的成员

public class Demo{
	public static void main(String[] args) {	
		
		Student.m2();
		
	}
	
}

class Student{
	//成员变量
	int a;
	//静态变量
	static int b;

	
	//成员方法
	public void m1() {
		System.out.println("成员方法被调用");
		
	}

	//静态方法
	public static void m2() {
		//创建对象
		Student s = new Student();
		System.out.println(s.a);
		s.m1();
		
		System.out.println("静态方法被调用");
		
	}

}


案例4：关于静态方法覆盖问题

public class Demo{
	public static void main(String[] args) {	
		
		Student s = new Student_166();
		s.m1();//
		s.m2();
		
	}
	
}

class Student{
	//成员变量
	int a;
	//静态变量
	static int b;

	
	//成员方法
	public void m1() {
		System.out.println("成员方法被调用");
		
	}

	//静态方法
	public static void m2() {
		
		
		System.out.println("静态方法被调用");
		
	}

}


class Student_166 extends Student{
	//覆盖m1
	public void m1() {
		System.out.println("子类 的m1");
		
	}
	
	
	//覆盖m2方法
	public static void m2(){
		System.out.println("子类的m2");
		
	}
}


案例5：关于this/super是否可以在静态方法中使用

public class Demo{
	public static void main(String[] args) {	
		
		Student s = new Student_166();
		s.m1();//
		s.m2();
		
	}
	
}

class Student{
	//成员变量
	int a;
	//静态变量
	static int b;

	
	//成员方法
	public void m1() {
		System.out.println("成员方法被调用");
		
	}

	//静态方法
	public static void m2() {
		int a = 40;
		System.out.println(this.a);
		
		System.out.println("静态方法被调用");
		
	}

}


class Student_166 extends Student{
	int a;
	//覆盖m1
	public void m1() {
		System.out.println("子类 的m1");
		
	}
	
	
	//覆盖m2方法
	public static void m2(){
		int a = 30;
		System.out.println(a);
		//System.out.println(this.a);
		System.out.println(super.a);
		
		System.out.println("子类的m2");
		
	}
}

static修饰初始代码块

初始代码块：在创建对象时 和 实例变量按照顺序进行初始化  也叫做动态代码块
语法：
{} 
案例：
成员变量先声明 默认值0----> 360--->250

public class Demo{
	public static void main(String[] args) {	
		Test t = new Test();
		System.out.println(t.c);
		
		//System.out.println(t.a);
	}
}

class Test{
	//成员变量
	//int a = 20;
	//初始代码块
	int c = 250;
	{   
		c = 360;
		/*int b = 30;//局部变量
		a = 10;//成员变量
		System.out.println(b);*/
		//System.out.println(c);
		
	}
	
}

=================================================================
static 修饰的初始代码块叫做静态代码块
静态代码块：在类加载的时候和类中静态属性按照顺序进行初始化
语法：
static{}
类变量先声明 默认值0----> 10--->20
案例：

public class Demo{
	public static void main(String[] args) {	
		Test t = new Test();
		System.out.println(t.b);
		System.out.println(Test.b);
		
		//System.out.println(t.a);
	}
}

class Test{
	//实例变量
	int a;
	//类变量
	static int b = 10;
	static{
		b = 20;
		System.out.println("静态代码块执行了 类加载了");
	}
================================================================
类加载：当第一使用一个类的时候会先将一个类加载到jvm中读出（属性  方法 包名 类名 等信息 存入到jvm）
|------------------- 硬盘 -----------------|  |--内存---|
.java(源文件)--->编译器--->.class(字节码文件)---->jvm(内存)

类加载的时机：
	1.第一次创建对象的时候会进行类加载
	2.当通过类名访问类中的静态成员的时候会进行类加载
	3.当创建子类对象的时候会先创建父类对象 这时候先会进行父类的类加载 再进行子类的类加载
	4.当通过类名进行访问子类中的静态成员 会先加载父类 然后再加载子类
	3-4合一：当子类进行类加载前会先进行父类的类加载
	5.当通过类名访问父类中的静态成员只会进行父类的类加载
	6.当创建父类对象时只会进行父类的类加载	

注意：类加载只进行一次

案例：

public class Demo{
	public static void main(String[] args) {	
		Test t = new Test();
	}
}

class Test{
	public  Test() {
		System.out.println("构造被调用  对象被创建");
		
	}
	//实例变量
	int a;
	//类变量
	static int b = 10;
	static{
		b = 20;
		System.out.println("静态代码块执行了 父类加载了");
		
	}

	public static void m1() {
		System.out.println("m1被调用");
		
	}
}

class Hello extends Test{
	static int c = 10;
	static{
		System.out.println("子类进行类加载了");
		
	}
}

final最终的

final修饰变量

final 修饰局部变量
特点：
	final 修饰的局部变量只能赋值一次 一旦赋值值不可改变
案例：
public class Demo{
	
}

class Test{

	public void m1() {
		final int a ;
		a = 10;
		a++;
		System.out.println(a);	
	}
}

==================================================================
final 修饰实例变量
特点：
	1.final 修饰的实例变量没有默认值
	2.final 修饰的实例变量只能赋值一次 一旦赋值不可改变
	3.fianl 修饰的实例变量可以在构造方法中进行初始化 但是要保证每个构造方法都对final修饰的实例变量进行初始化
案例：

public class Demo{
	public static void main(String[] args) {
		Test t = new Test(20);
		System.out.println(t.a);
			
	}
	
}

class Test{

	//实例变量
	final int a;

	//构造方法
	public  Test(int a) {
		this.a = a;
	}

	public  Test(String n,int a) {
		this.a =a;
	}
}




==================================================================
final 修饰静态变量
特点：
	1. final 修饰的静态变量没有默认值
	2. final 修饰的静态变量只能赋值一次 一旦赋值无法改变
	3. final 修饰的静态变量可以在静态代码块中进行初始化
注意： final 修饰的静态变量称之为常量 
常量的定义语法： public static final 数据类型 常量名 = 常量值；
例如： public static final int a = 3;
案例： 
class Test{

	//类变量
	final static int a;

	static{
		a = 10;
		//a++;
		
	}
	
}

===============================================================
注意：
	当final修饰简单数据类型的变量时 只能赋值一次不能改变变量值
	当final修饰的引用数据类型的变量时 不能再次改变的是地址值

final修饰方法

final 修饰成员方法
语法：
访问修饰符 final 返回值类型 方法名(形参列表){}
final 访问修饰符 返回值类型 方法名(形参列表){}
特点：
	1. final 修饰的成员方法可以重载
	2. final 修饰的成员方法可以被继承 ，但是不能被覆盖
案例：

public class Demo{
	public static void main(String[] args) {
		Sub s = new Sub();
		s.m1();
		
			
	}
	
}

class Super{

	public final void m1() {
		System.out.println("m1");
		
	}
	 
	
}

class Sub extends Super{
	public final void m1() {
		System.out.println("sub m1");
	}
}

==================================================================
final 修饰静态方法
语法：
访问修饰符  final  static 返回值类型  方法名(形参列表){}
访问修饰符/final/static 顺序前后都可以
特点：
	1. final 修饰的静态方法可以被重载
	2. final 修饰的静态方法可以被继承  但是不能被覆盖
案例：

public class Demo{
	public static void main(String[] args) {
		Sub s = new Sub();
		s.m1();
		
			
	}
	
}

class Super{

	public  static final void m1() {
		System.out.println("super m1");
		
	}
}

class Sub extends Super{
	public static final void m1() {
		System.out.println("sub m1");
		
	}
}

final修饰类

final 修饰的类
语法：
final class 类名{

}

特点：
	final 修饰的类没有子类 俗称 断子绝孙类 
java类库中常见的断子绝孙类  Math 类  System  String
案例：

public class Demo{
	public static void main(String[] args) {
		/*Sub s = new Sub();
		s.m1();*/
		
			
	}
	
}

final class Super{

	public  static final void m1() {
		System.out.println("super m1");
		
	}
}

class Sub extends System{
	
}