四种访问权限符 和 内部类
四种访问权限符
概述
在Java当中提供了四种权限修饰符,使用不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限
类的修饰符只有 public , abstract,final 关键字所修饰,其他关键字修饰是非法的,不可以的.
-
权限:指代作用范围
public < protected < (default) < private -
同一个类
-
同一个包
-
不同包的子类
-
不同包的非子类
备注:颜色可以代表访问修饰符,实心和空心代表成员方法和成员变量
- 黄色:protected 受保护的
- 绿色: public 公共的
- 蓝色:(default) 默认的
- 红色: private 私有的
编写代码建议使用:
成员变量:建议使用 private ,隐藏细节
构造方法: 建议使用 public ,便于调用
成员方法: 建议使用 public ,便于调用
| 1 | public | protected | (default) | private |
|---|---|---|---|---|
| 同一个类 | yes | yes | yes | yes |
| 同一个包 | yes | yes | yes | no |
| 不同包的子类 | yes | yes | no | no |
| 不同包的非子类 | yes | no | no | no |
注意事项:(default)并不是关键字,可以默认不写.
- 一个类文件里只能有一个public修饰的类,但可以包含其他类,而且.java源文件的名称也是这个被public修饰的类名,但是一个类的内部可以用public修饰符,充当成员信息
内部类
理解内部类:
如果一个事物的内部又同时包含另外一个事物,那么这就是一个类的内部包含了另一个类
例如: 身体里的心脏,身体和心脏的关系是"has-a"的关系
内部类的优点:
- 内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
- 内部类是另外一种封装，对外部的其他类隐藏。
- 内部类可以实现java的单继承局限。
内部类缺点
结构复杂,不易理解
创建内部类
在外部类的外部,想要使用非静态内部类,创建格式
语法： 外部类.内部类 内部类对象 = new 外部类().new 内部类();
举例： Outer.Inner in = new Outer().new Inner();
在外部类的外部,想要使用静态内部类,创建格式
语法： 外部类.内部类 内部类对象 = new 外部类.内部类();
举例： Outer.Inner in = new Outer.Inner();
对内部类的分类
- 成员内部类
- 静态内部类
- 方法内部类
- 匿名内部类
成员内部类
成员内部类:定义在类中方法外的内部类,在外部类的成员信息位置,与外部类的对象有关
格式:
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//......
}
//......
}
代码演示:外部类的成员方法获得成员内部类的成员方法,并执行
//定义一个身体类
//外部类
public class Body{
//成员内部类
public class Heart{
//成员内部类的普通方法
public void beat(){
System.out.println("这是内部类的方法.");
System.out.println("心脏在跳动,砰砰砰");
}
}
//外部类的普通方法
public void methodBody(){
System.out.println("这是外部类的方法...");
//在外部类的方法里访问内部类的普通方法
//创建内部类的对象,利用对象调用
// Heart heart = new Heart();
// heart.beat();
//或者采用匿名对象的方式访问内部类的普通方法
new Heart().beat();
}
public static void main(String[] args){
Body body = new Body();
body.methodBody();
}
}
运行结果:
-
代码演示:使用内部类完成多继承
//定义类A
class A{
private String name = "A类的私有域";
//提供get方法
public String getName() {
return name;
}
}
//定义类B
class B{
//定义类B的私有属性
private int age = 20;
//提供get方法
public int getAge() {
return age;
}
}
//定义外部类
class Outter{
//定义内部类
private class InnerClassA extends A{
//内部类A的成员方法name()
public String name() {
return super.getName();
}
}
private class InnerClassB extends B{
//内部类B的成员方法age()
public int age() {
return super.getAge();
}
}
//定义外部类的普通方法
public String name() {
return new InnerClassA().name();
}
public int age() {
return new InnerClassB().age();
}
}
//测试类
public class Test2 {
public static void main(String[] args) {
//创建外部类对象
Outter outter = new Outter();
System.out.println(outter.name());
System.out.println(outter.age());
}
}
匿名内部类
匿名内部类
匿名内部类就是一个没有名字的方法内部类，因此特点和方法与方法内部类完全一致，除此之外，还有自己的特点：
1.匿名内部类必须继承一个抽象类或者实现一个接口。
2.匿名内部类没有类名，因此没有构造方法。
代码演示
//匿名内部类
//声明一个接口
interface MyInterface {
//接口中方法没有方法体,抽象方法
void test();
}
//外部类
class Outer{
private int num = 5;
public void dispaly(int temp)
{
//匿名内部类，匿名的实现了MyInterface接口
//隐藏class类声明,没有类名,不能有构造方法
new MyInterface()
{
public void test()
{
System.out.println("匿名实现MyInterface接口");
System.out.println(temp);
}
}.test();
}
}
public class Test3{
public static void main(String[] args)
{
Outer out = new Outer();
out.dispaly(3);
}
}
注意事项:外部类的方法访问内部类的方法,直接在外部类的方法里创建内部类的对象,然后通过对象调用.也可以通过匿名对象调用
类的权限修饰符：
- 外部类：public
- 成员内部类： 都可以使用
- 局部内部类： 都不可以使用
浙公网安备 33010602011771号