Java部分修饰符小结

Java复习—修饰符总结

权限修饰符

权限修饰符：用来控制类、变量和方法的被访问的范围的

public(公共访问控制符)：对所有类可见。
private(私有访问控制符):只允许自己的类访问，其他任何类（子类）均不能访问。
protected(保护访问控制符):统一包内或者不同包中的子类可见。
default（默认，什么都不写）：对同一包内可见。

注意

private和protected不能修饰类（外部类）

小结

非访问修饰符

为了实现一些其它功能，Java也提供了许多非访问修饰符。

static修饰符：用来修饰类方法和类变量。
final：用来修饰类、方法和变量。
abstract：创建抽象类和抽象方法。
synchronized：主要用于线程的编程。

注意

final修饰的类不能够被继承，修饰的方法不能被重写，修饰的变量为常量，不可修改。

static

含义

static是一个修饰符，用于修饰成员，被修饰的成员是属于类的，而不是单单是属于某个对象的
static优先于对象存在，因为static的成员随着类的加载就已经存在了
static修饰的成员多了一种调用方式，可以直接被类名所调用，格式：类名.静态成员
static修饰的数据是共享数据，对象中存储的是特有数据

注意

静态方法只能访问静态成员（非静态既可以访问静态，又可以访问非静态）
静态方法不可以定义this或super关键字
构造方法、局部变量不能被static修饰

静态变量和成员变量的区别

两个变量的声明周期不同：
成员变量随着对象的创建而存在，随着对象的被回收而释放；
静态变量随着类的创建而存在，随着类的消失而消失；

调用方法不同：
成员变量只能被对象调用；
静态变量可以被对象调用，还可以被类名调用；

别名不同
成员变量也称为实例变量；
静态变量也成为全局变量；

存储位置不同
成员变量数据存储在堆内存的对象中，也叫对象的特有数据；
静态变量数据存储在方法区（的静态区）中，也叫对象的共享数据。

 public class ClsA{ 	
	public static int a=30;
	private  int  m_b=40;
	public  static void show(){
		a=50;
		m_b=60;//static方法不能访问成员变量。
	}
}
// 全局变量或方法在类外均通过类名访问
ClsA.a=9999;	
ClsA.show();

this

含义

作用：当成员变量和局部变量重名，可以用关键字this来区分。
本质：所在方法调用者的地址值。
this可以实现以下三类结构的描述：
·当前类中的属性：this.属性；
·当前类中的方法（普通方法、构造方法）:this()、this.方法名称（）；
·描述当前对象；

 public class Car{ 
	private String colour;
	private String brand;
	//定义一个Car类的构造方法
	Car(String colour, String brand){ 	//带参数的构造方法
		this.colour = colour;
		this.brand = colour;
	}
	public void run(){
		System.out.println("品牌：" + brand +"；颜色："+ colour);
	}
	public static void main(String[] args){
		Car c = new Car(“black”,”Volve”);
		Car c1 = new Car("red","BMW");
		c.run();	
		c1.run();
	}
}

extends

含义

子类继承父类

class Cat extends Pet

注意

接口支持继承，也支持多重继承。

interface  接口名  extends  接口1, 接口2,…… {
	……
}

super

含义

在继承关系中代指父类（类似this）

对比this

注意

在一个构造方法中，只能访问一次其它的构造方法（不管是父类的还是子类的）,所以此时不能同时用super和this关键字来调用构造方法，只能根据需求选其一。

public class Pet {
    protected String name;
    protected String color;
    protected String breed;//品种
    public Pet() {}
    public Pet(String name, String color, String breed) {
        super();
        this.name = name;
        this.color = color;
        this.breed = breed;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getBreed() {
        return breed;
    }
    public void setBreed(String breed) {
        this.breed = breed;
    }
    public void cry() {
    }
    @Override
    public String toString() {
        return "我叫" + name + ", 是一只" + color + "的" + breed;
    }
}

public class Cat extends Pet{
    public Cat() {
        super();
    }
    public Cat(String name, String color, String breed) {
        super(name, color, breed);
    }
    @Override
    public void cry() {
        System.out.println("我会喵喵喵...");
    }
    @Override
    public String toString() {
        return "我是一只猫。" + super.toString();
    }
}

运行结果：

final

含义

用来修饰一个类：不能被继承
用来修饰一个方法：这个方法最终方法，不能被覆盖重写
用来修饰一个局部变量：不能被改变，一次赋值终生不变
用来修饰一个成员变量：不能被改变，不会再给默认值，需要手动赋值

注意

常量只能赋值一次

 final  int  NUM1 = 20;	 //在定义的时候初始化。
 NUM1 =30;		 //不允许，因为常量不能二次赋值。 
 final  int  NUM2;
 NUM2=20;		//允许，因为常量j在这里是第一次赋值。
 NUM2=30;		//不允许，因为常量不能二次赋值。 

abstract

含义

用关键字abstract修饰的方法称为抽象方法。抽象方法只允许声明，不允许实现，即抽象方法只有方法声明，而没有方法体。
语法格式：修饰符 abstract 返回值类型 方法名 (参数列表)；

abstract class Pet {
    public abstract void cry();   
}

注意

包含抽象方法的类一定是抽象类
抽象类不能使用new关键字创建对象
抽象类必须有子类

interface

含义

声明接口

public interface 接口名称{
	//接口内容
}

abstract

含义

声明抽象方法

[public]  [abstract]  返回值类型  方法名称（参数列表）;

implements

含义

一个类通过使用关键字implements声明自己实现接口，这个类称为实现类

public class 实现类名称 implements 接口1,接口2,……{
	//实现类内容
}

注意

1.一个类可以实现多个接口，需要用逗号将接口名隔开。如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
2.一个类可以在继承某个类（只能一个，而且可以是抽象类）的同时实现一个或多个接口。注意：implemets如果存在的话必须在最后，不能在extends前。

Class Dog extends Pet implements Eatable, Sleepable{
    ……
} //Dog类在继承父类Pet的同时实现Eatable和Sleepable两个接口