java内部类-小白学习中

java内部类

分类：
1.成员内部类
2.局部内部类（包含匿名内部类）

成员内部类

格式：
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//…
}
//…
}
注意：内用外，随意访问；外用内，需要内部类对象。
调用：
1.间接方法：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法。
格式：外部类名称 对象名=new 外部类名称()；
2.直接方法：
格式：外部类名称.内部类名称 对象名=new 外部类名称().内部类名称();
注意：如果内部类需要调用同名的外部类的成员变量，其格式为：
外部类名称.this.外部类成员变量名;

局部内部类

格式：
修饰符 class 外部类名称{
修饰符 返回值类型 外部类名称（参数列表）{
class 局部内部类名称{
//…
}
}
}
注意：局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从Java 8开始，只有局部变量事实不变，那么final关键字可以省略。
原因：
1.new出来的对象在堆内存当中。
2.局部变量跟着方法走的，在栈内存当中。
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4.但是new出来的对象会在堆当中持续存在。

==================================================
权限修饰符：
public>protected>(defoult)>private
1.外部类：public/protected
2.成员内部类：public/protected/(defoult)/private
3.局部内部类：什么都不能写

==================================================

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
格式：
接口名称 对象名=new 接口名称(){
//覆盖重写所有抽象方法
}；

对格式“new 接口名称（）{…}”进行解析：
1.new代表创建对象的动作。
2.接口名称就是匿名内部类需要实现哪个接口。
3.{…}这才是匿名内部类的内容。

注意：
1.匿名内部类，在【创建对象】的时候，只能使用唯一的一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2.匿名对象，在【调用方法】的时候，只能调用唯一的一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】。
匿名内部类和匿名对象不是一回事。

==================================================
接口：

public interface llInterNi {
void slInter1();
void slInter2();
}

外部类：

public class llBody implements llInterNi{
int num=10;
@Override
public void slInter1() {
System.out.println(“实现类重新方法”);
}
@Override
public void slInter2() {
System.out.println(“实现类重新方法”);
}
public class Heart{//成员内部类
int num=20;
public void slBeat(){
System.out.println(“内部类的方法”);
System.out.println(name);//正确写法
}
public void slInter(){
int num=30;
System.out.println(num);//内部类方法的局部变量
System.out.println(this.num);//内部类的成员变量
System.out.println(llBody.this.num);//外部类的成员变量
}
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void slBody(){
System.out.println(“外部类的方法”);
}
public void sluser(){
Heart heart=new Heart();
heart.slBeat();
}
public void slOuter(){
class Inter{//局部内部类
int num=10;
public void slOuterin(){
System.out.println(num);
}
}
Inter inter=new Inter();
inter.slOuterin();
}
}

测试类：

public class llBodyTest {
public static void main(String[] args) {
llBody body=new llBody();//外部类对象
//通过外部类的对象，调用外部类的方法，里面间接在使用内部类的Heart
body.sluser();
//直接方法
llBody.Heart heart=new llBody().new Heart();
heart.slInter();
body.slOuter();
body.slInter1();
//使用匿名内部类
llInterNi ni=new llInterNi() {//创建匿名对象
@Override
public void slInter1() {
System.out.println(“重写”);
}
@Override
public void slInter2() {
System.out.println(“重写2”);
}
};
ni.slInter1();
ni.slInter2();
new llInterNi() {
@Override
public void slInter1() {
System.out.println(“重写”);
}
@Override
public void slInter2() {
System.out.println(“重写2”);
}
}.slInter2();
}
}