Core Java第八章知识点总结——三个修饰符

Core Java第八章知识点总结——三个修饰符

知识点预览

static修饰符

final修饰符

abstract修饰符

 

static修饰符

 

1.static修饰符可以修饰什么

属性

方法

静态代码块

2. static修饰属性

a) static可以修饰属性（静态属性），不可以修饰局部变量

TestStatic1

b) static修饰属性的特点

                       i. static修饰的属性全类公有 TestStatic

 

package chp8.ex01;

/**
 * 
 * 说明：本程序演示了static修饰属性的用法 全类共有
 */
class MyValue{
	int a;
	static int b;//静态属性
}
public class TestStatic{
	public static void main(String args[]){
		MyValue mv1 = new MyValue();
		MyValue mv2 = new MyValue();
		mv1.a = 100;
		mv1.b = 200;
		mv2.a = 300;
		mv2.b = 400;
		System.out.println(mv1.a);
		System.out.println(mv1.b);//400
		System.out.println(mv2.a);
		System.out.println(mv2.b);//400 MyValue.b 亦可
}                                                              
}

                     ii.  static修饰的属性可以通过类名访问 MyValue.b

                 iii. static修饰的属性也叫做类变量

                 iv. static修饰的属性什么时候被初始化

类加载的时候初始化static修饰的变量

使用类之前，一个类只加载一次

.class------->内存------->JVM内存------->对象

私有访问修饰符 private

2个方法 获得 设置

3.  static修饰方法

a)static修饰的方法称为静态方法 public static 和static public均可

b)  静态方法可以通过类名调用 TestStaticMethod.test();

c) 非静态方无论属性和方法是否是静态的都可以访问

d)静态方法只能访问静态属性和静态方法 TestStaticMethod3

package chp8.ex04;

/**
 * 
 * 说明：本程序演示了static修饰方法的用法
 */
public class TestStaticMethod3 {
    static int a= 10;
    int b = 20;
    public void test1(){}
    public static void test2(){}
    //静态方法只能访问静态属性和静态方法
    public static void test3(){
    	System.out.println(a);
    	//System.out.println(b); //错误
    	//test1(); //错误
    	test2();
    }
}

e) 静态方法中不能使用this关键字

f)非静态方法只能覆盖非静态方法

g)静态方法只能覆盖静态方法，但是没有多态 TestStaticOverride

 

package chp8.ex05;

/**
 * 
 * 说明：本程序演示了静态方法的覆盖用法
 */
public class TestStaticOverride {
   public static void main(String args[]){
	   Super s = new Sub();
	   //输出this is super
	   s.m();//等效于 Super.m()
   }
}
class Super{
  public static void m(){
	 System.out.println("this is super");
  }
}
class Sub extends Super{
	//静态方法只能覆盖静态方法，但是没有多态
  public static void m(){
	 System.out.println("this is sub");
  }	
}

 

4. 静态代码块

a)  静态代码块的概念

在类加载时执行静态代码块的内容

static{} 一般是对资源操作的内容

final修饰符

1.  final修饰符可以修饰什么

a)  变量

b) 方法

c) 类

 

2.  final修饰变量

a)  final修饰变量（属性、局部变量）

一旦赋值其值不可改变

b)final修饰局部变量----->常量（以大写形式声明）

TestFinalLocalVar1

 

 

package chp8.ex07;
/**
 * 
 * 说明：本程序演示了final修饰属性的用法
 */
public class TestFinalLocalVar1 {
   public static void main(String args[]){
	   final int A = 10;//一旦赋值 其值不可改变
	   //A++ //错误 
   }
}

TestFinalLocalVar2

package chp8.ex08;
/**
 * 
 * 说明：本程序演示了final修饰类变量的用法
 */
public class TestFinalLocalVar2 {
  public static void main(String args[]){
	 final MyClass M1 = new MyClass();//final MyClass 引用存储的地址不可变 但是类的属性值可以改变
	  M1.value = 20;
	  M1.value = 30;
	 //The final local variable M1 cannot be assigned. It must be blank and not using a compound assignment
	 //M1 = new MyClass();//错误
  }
}
class MyClass{
   int value;
}

final MyClass 引用存储的地址不可变

3. final修饰属性

a)  final修饰属性时，必须对属性显示赋值或者提供构造方法对属性赋值

构造得到重载必须对属性赋值

不能同时采用显示赋值或者提供构造方法对属性赋值

b) final static一起修饰属性（如果是final修饰变量，推荐一起使用）

单独的final------->浪费资源，没有意义

static final intI = 10;//减少内存占用

4.  final修饰方法和类（不能被改变）

a) final修饰符修饰的方法不能被子类覆盖

b) final修饰符修饰的类不能被继承

 

abstract修饰符

 

1.  abstract修饰符可以修饰什么

类

方法

2.  abstract修饰符修饰类

a)   abstract修饰符修饰的类叫做抽象类

abstract class

b)  抽象类的特点

                       i. 抽象类可以用于声明，但不允许创建对象

MyClass m1;//正确

              m1 = new MyClass;//错误

                     ii.抽象类可以被子类继承，从而创建子类对象

3.抽象方法

a) abstract修饰的方法叫做抽象方法

只有声明没有实现

b) 抽象方法的特点

                       i. 拥有抽象方法的类必须是抽象类

                     ii. 抽象类不一定有抽象方法

                   iii. 抽象方法由子类实现

4. 抽象的作用

 

 

 

抽象类是更高层次的抽象

子类共性的方法抽取成抽象方法，形成一种概念性质的类，抽象方法由其子类实现

 

 

package chp8.ex15;
/**
 * 
 * 说明：本程序演示了抽象类的具体抽象
 * 抽象类是更高层次的抽象
 * 子类共性的方法抽取成抽象方法，形成一种概念性质的类，抽象方法由其子类实现
 */
public class TestAbstract {
  public static void main(String args[]){
	    Shape s = new Circle(3);
	    double grith = s.girth();
	    System.out.println("grith is "+grith);
  }
}
//抽象类
abstract class Shape{
	public abstract double girth();
	public abstract double area();
}
//子类 实现其抽象方法
class Circle extends Shape{
	private double r;
    private static final double PI = 3.1415926;
	public Circle(double r){
		this.r = r;
	}
	public double girth(){
		return 2*PI*r;
	}
	public double area(){
		return PI*r*r;
    }
}
//子类 实现其抽象方法
class Rect extends Shape{
	private double a;
	private double b;
	public Rect(double a, double b){
		this.a = a;
		this.b = b;
    }
    public double girth(){
		return 2*(a+b);
	}
	public double area(){
		return a*b;
	}
}