Java零基础进阶篇之面向对象-访问控制权限

本篇文章讲解的知识点主要围绕面向对象中的访问控制权限，废话不多说，只分享Java相关的干货！

java 访问级别修饰符主要包括：private protected 和 public，可以限定其他类对该类、属性和方法的使用权限，

注意以上对类的修饰只有：public 和 default，内部类除外

 

1、private

【示例代码】

 

public class PrivateTest01 {


public static void main(String[] args) { A a = new A();
//不能访问，private 声明的变量或方法，只能在同一个类中使用
System.out.println(a.id);
}
}

class A {

private int id;


}

2、protected

【代码实例】，在同一个包下，建立类 ProtectedTest01、A，并建立 B 继承 A

public class ProtectedTest01 {

public static void main(String[] args) { A a = new A();
a.method1();  A b = new B(); b.method1();

B b1 = new B(); b1.method3();
}
}


class A {

//采用protected 声明的变量或方法只有子类或同一个包下的类可以调用
protected int id = 100;


public void method1() { System.out.println(id);
}


protected void method2() { System.out.println("A.method2()");
}
}


class B extends A {


public void method1() {
//因为和A 在同一个包下
System.out.println(id);
}


public void method3() {
//可以正确调用method2();
}
}

【代码示例】，在 test1 下建立类 C1，在 test2 下建立 ProtectedTest02 和 C2 类

package test2;

import test1.C1;


public  class ProtectedTest02 {

public static void main(String[] args) { new C2().method2();
}
}

class C2 extends C1 {

public void method2() {
//可以调用，主要原因C2 是 C1 的子类
//所以可以访问protected 声明的变量
System.out.println(id); method1();
}
}

class C3 {

public void method3() {
//不能在其他类中访问protected 声明的方法或变量
//new C1().method1();
}
}

 

3、default

如果 class 不采用 public 修饰，那么此时的 class，只能被该包下的类访问，其他包下无法访问

import test3.D;


public class DefaultTest01 {

public static void main(String[] args) { D d = new D();
d.method1();

//不能访问，只有在一个类中或在同一个包下可以访问
//在子类中也不能访问d.method2();
}
}

 

内部类

在一个类的内部定义的类，称为内部类

内部类主要分类：

• 实例内部类

• 局部内部类

• 静态内部类

1、实例内部类

• 创建实例内部类，外部类的实例必须已经创建

• 实例内部类会持有外部类的引用

• 实例内部不能定义 static 成员，只能定义实例成员

public class InnerClassTest01 {


private	int a;

private int b;


InnerClassTest01(int a, int b) { this.a = a;
this.b = b;
}

//内部类可以使用private 和protected 修饰
private class Inner1 { int i1 = 0;
int i2 = 1;

int i3 = a; int i4 = b;
//实例内部类不能采用static 声明
//static int i5 = 20;
}

public static void main(String[] args) {
InnerClassTest01.Inner1 inner1 = new InnerClassTest01(100, 200).new Inner1();
System.out.println(inner1.i1); System.out.println(inner1.i2); System.out.println(inner1.i3); System.out.println(inner1.i4);
}
}

 

2、静态内部类

• 静态内部类不会持有外部的类的引用，创建时可以不用创建外部类

• 静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

【示例代码】

public class InnerClassTest02 {

static int a = 200;


int b = 300;

static class Inner2 {
//在静态内部类中可以定义实例变量int i1 = 10;
int i2 = 20;

//可以定义静态变量static int i3 = 100;

//可以直接使用外部类的静态变量static int i4 = a;

//不能直接引用外部类的实例变量
//int i5 = b;

//采用外部类的引用可以取得成员变量的值int i5 = new InnerClassTest02().b;

}

public static void main(String[] args) {
InnerClassTest02.Inner2 inner = new InnerClassTest02.Inner2(); System.out.println(inner.i1);
}
}

3、局部内部类

局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样局部内部类和实例内部类一致，不能包含静态成员

public class InnerClassTest03 {


private int a = 100;

//局部变量，在内部类中使用必须采用final 修饰
public void method1(final int temp) { class Inner3 {

int i1 = 10;

//可以访问外部类的成员变量int i2 = a;

int i3 = temp;
}

//使用内部类
Inner3  inner3 = new Inner3();

System.out.println(inner3.i1); System.out.println(inner3.i3);
}

public static void main(String[] args) {
InnerClassTest03 innerClassTest03 = new InnerClassTest03(); innerClassTest03.method1(300);
}
}

4、匿名内部类

是一种特殊的内部类，该类没有名字

• 没有使用匿名类

public class InnerClassTest04 {


public static void main(String[] args) {
MyInterface myInterface = new MyInterfaceImpl(); myInterface.add();
}
}

interface MyInterface {

public void add();
}


class MyInterfaceImpl implements MyInterface {

public void add() {
System.out.println("-------add	");
}
}

• 使用匿名类

public class InnerClassTest05 {

public static void main(String[] args) {
/*
MyInterface myInterface = new MyInterface() { public void add() {
System.out.println("-------add	");
}
};
myInterface.add();
*/


/*
MyInterface myInterface = new MyInterfaceImpl(); InnerClassTest05 innerClassTest05 = new InnerClassTest05(); innerClassTest05.method1(myInterface);
*/
InnerClassTest05 innerClassTest05 = new InnerClassTest05(); innerClassTest05.method1(new MyInterface() {
public void add() {
System.out.println("-------add	");
}
});


}



private void method1(MyInterface myInterface) { myInterface.add();
}
}


interface MyInterface {


public void add();
}


/*
class MyInterfaceImpl implements MyInterface {
public void add() {
System.out.println("-------add	");
}
}
*/

以上就是访问控制权限相关的知识点了，配套视频教程，正在学习Java的同学们一定要持续关注哦~~

Java零基础进阶视频教程