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;
}
}