看完了面向对象。看完了封装,继承接下来介绍一下内部类和权限修饰符
一、内部类
1、顾名思义,定义在内部的类,可以定义在方法中,也可以定义在类中,方法外
2、根据定义的位置不同:
(1) 成员内部类
:
① 普通的成员内部类
② 私有的成员内部类
③ 静态的成员内部类
(2) 局部内部类
了解了分类,下面进行详细介绍
(1)成员内部类
1、定义在成员位置上的类
2、格式:
class内部类名{
内部类的成员
}
3、成员内部类的说明:
(1) 内部类可以访问外部类中的所有成员,包括私有成员
(2) 外部类中访问内部类中的成员,必须
创建内部类对象
4、内部类创建对象的格式:
(1) 外部类名.内部类名 对象名 = new 外部类名().new 内部类名()
public class Demo01 {
public static void main(String[] args) {
//第一方式,直接创建内部类对象,访问内部类中的内容
Body b = new Body();
Body.Heart bh = b.new Heart();
bh.show();
// Body.Heart bg = new Body().new Heart();
//第二种方式,可以创建外部类对象,通过外部类对象提供的方法,去访问内部类对象
b.test();
}
}
//定义在类的内部的类
class Body {//定义一个金龙的身体
private double height = 149.99;
// Heart在Body类中,首先是一个成员,想要访问这个成员,需要先创建外部类对象
// 创建完外部类对象之后,可以访问这个这个成员,想要访问内部类中的成员,要创建内部类对象
// 想要获取金龙的心脏,需要先拿到身体,剖开身体,才能拿到心脏
//成员的位置上定义一个类
class Heart { //成员内部类====在这里!!!!!
int beats = 200;//每分钟
public void show() {
System.out.println(height + "~~~~~" + beats + "DuangDuangDuang");
print(); //可以相互调用
}
}
//内部类外
//可以定义一个方法 然后去创建内部类对象,访问属性
public void test(){//外部类中此时都是成员,成员直接可以直接相互访问
//但是要访问的成员又是一个类,想要拿到该类中的一些内容,需要创建对象
Heart h = new Heart();
System.out.println(h.beats);
h.show();
}
public void print(){
System.out.println("准备干饭");
}
}
(2)私有的成员内部类
1、加上private
2、访问方式:
(1) 在外部类以外,不能访问内部类中定义的私有成员
(2) 在外部类定义公共的方法,让外界调用公共的方法,间接的访问内部类中的私有成员.
(3)适用情景:
如果一个内部类只希望被外部类中的方法操作
,那么可以使用private声明内部类。也就是说,此时的内部类只有外部类可控制
就像是,我的心脏只能由我的身体控制,其他人无法直接访问它
public class Demo02 {
public static void main(String[] args) {
Body b = new Body();
System.out.println(b.getHeight());
b.gaYaoZi();
}
}
//金龙的身体
class Body{
private double height = 159.9;
private class YaoZi{ //私有的成员内部类====在这里!!!!!
//定义一个腰子的年龄
int age = 80;
public void show(){
System.out.println(height + "缺钱的时候别来找我,我已经不行了" + age);
}
}
//访问私有的成员需要提供公共的访问方式
public double getHeight(){
return height;
}
//私有的成员:成员变量 成员方法 私有成员内部类
//私有的成员只能在本类中被直接访问
//现在想要访问私有成员内部类中的age
//需要创建对象,提供公共的方法
public void gaYaoZi(){
//相当于一个公共的访问方式
YaoZi y = new YaoZi();
//所以一般私有内部类,要求提供一个公共的访问方式,完成该类型的访问
System.out.println(y.age);
y.show();
}
}
(3)静态的成员内部类
1、很简单加上static 就变成静态了
2、访问特点:
(1) 是外部类的静态成员,直接通过类名访问,而不需要创建对象
(2) 静态内部类的非静态成员,需要等所在的内部类对象创建之后,才能被调用
(3) 是否需要创建对象,取决于要访问的成员是否是静态
public class Demo03 {
public static void main(String[] args) {
System.out.println(Body.Gan.age);
// System.out.println(Body.Gan.color);
//因为可以直接拿到Gan这个类型, 类名.静态成员名
//该成员又是一个类,所以创建该成员的对象
//此时就可以访问该类中的内容
Body.Gan gan = new Body.Gan();
System.out.println(gan.color);
gan.show();
}
}
//金龙的身体
class Body {
private double height = 169.99;
static class Gan{ //静态的成员内部类====在这里!!!!!
String color = "Green";
static int age = 2;
public void show(){
//想要访问非静态的内容,需要创建对象,通过对象来访问
Body b = new Body();
System.out.println(b.height + color + "别喝了,再喝头顶就可能绿的发光了");
}
}
//在外部类中,访问内部类
public void test(){
System.out.println(Gan.age);
//想要访问颜色
//想要访问一个类的内部的非静态成员,不是取决于这个类是否是静态
//而是取决于这个成员是否是静态。不是就需要创建对象
Gan g = new Gan();
System.out.println(g.color);
}
}
(4)局部内部类
1、定义在方法内部的类
2、局部内部类的访问方式:
(1) 方法内的局部变量,外界不能访问
(2) 同样,方法内的局部内部类,也不能在方法外被访问
3、解决方式:
(1) 在方法里,就完成该局部内部类的使用,创建局部内部类对象,调用对象相关的方法
(2) 外界调用局部内部类所在的方法,创建局部内部类对象,间接的访问局部内部类的成员
4、好处(重点):
将一个类的生命周期,限制在了一个方法内
public class Demo04 {
public static void main(String[] args) {
}
//金龙在呼吸
public static void breath(){
//肺的年龄
int fei = 50;
class Fei{ //方法里面的类!!!=>局部内部类
//作用域只在当前方法内
String color = "black";
public void show(){
System.out.println(fei + "~~~~~~~~" + color + "抽的太少了,来的刺激的,能一下过去的");
}
}
//方法中的类必须在方法内使用,出了方法不能访问
//好处就是将一个类的生命周期限制在一个方法内
Fei f = new Fei();
System.out.println(f.color);
f.show();
}
}