1.内部类的概念与分类
如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。 例如:身体和心脏的关系,又如:汽车和发动机的关系。 分类 1:成员内部类 2:局部内部类(包含匿名内部类) 成员内部类的定义格式: 修饰符 class 类名称{ 修饰符 class 类名称{ //... } //... } 注意事项: 内部用外部,随意访问:外部用内部,需要内部类对象。
public class Body {//成员内部类
public class heart {
//内部类的方法
public void beat(){
System.out.println("心脏跳动:咚咚咚");
System.out.println("我叫:"+name);//正确写法
}
}
//外部的成员变量
private String name;
//外部类的方法
public void methodBody(){
System.out.println("外部类的方法");
}
}
2.成员内部类的使用
如何使用成员内部类?有两种方式: 1:间接方式:在外部类的方法当中,使用内部类:然后main只是调用外部类的方法 2:直接方式,公式: 类名称 对象名 = new 对象名(); 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
public class InnerClass {
public static void main(String[] args) {
Body body = new Body();
//通过外部类的对象,调用外部类的方法,里面间接在使用内部类heart
body.methodBody();
System.out.println("===============");
//按照公式
Body.heart heart = new Body().new heart();
heart.beat();
}
}
3:内部类的同名变量访问
如果出现重名现象,那么格式是:外部类名称.this.外部类成员变量名
public class Outer {
int num = 10;//外部的成员变量
public class Inner {
int num = 20;//内部类的成员变量
public void methodInner(){
int num = 30;//内部类方法的局部变量
System.out.println(num);//局部变量就近原则
System.out.println(this.num);//内部类的成员变量
System.out.println(Outer.this.num);//外部类的成员变量
}
}
}
public class DemoInnerClass{
//外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称;
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.methodInner();
}
}
4:权限修饰符的注意事项
如果一个类是定义在一个方法内部的,那么就是一个局部内部类。 “局部”:只有当前所属的方法才能使用它,除了这个方法外面就不能用了。 定义格式: 修饰符 class 外部类名称 { 修饰符 返回值类型 外部类方法名称(参数列表){ class 局部内部类名称{ //。。。。 } } } 小结一下类的权限修饰符: public > protected > (default) > private 定义一个类的时候,权限修饰符规则: 1:外部类:public / (default) 2:成员内部类:public > protected > (default) > private 3:局部内部类:什吗都不能写
public class OuterA {
public void methodOuter(){
class inner{//局部内部类
int num = 10;
public void methodInner() {
System.out.println(num);
}
}
inner inner = new inner();
inner.methodInner();
}
}
public class DemoMain {
public static void main(String[] args) {
OuterA outer = new OuterA();
outer.methodOuter();
}
}
5:局部内部类final的问题
局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是[有效final的]。 备注:从JAVA 8+开始,只要局部变量试试不变,那么final关键字可以省略 原因: 1:new出来的对象在堆内存当中。 2:局部变量是跟着方法走的。在栈内存当中。 3:方法运行结束之后,立刻出栈,局部变量就会立刻消失。 4:new出来的对象会在堆当中持续存在,直到垃圾回收消失。
public class MyOuter {
public void methodOuter(){
int num = 10;//所在方法的局部变量
class MyInner{
public void myInner(){
System.out.println(num);
}
}
}
}
6.匿名内部类的注意问题
如果接的实现类(或者是父类的子类)只需要使用唯一的一次。 那么这种情况下就可以省略掉该类的定义,而改为使用[匿名内部类] 匿名内部类的定义格式: 接口名称 对象名 = new 接口名称(){ //覆盖重写所有抽象方法 }; 对“new 接口名称(){。。。。。}”格式进行解析: 1:new 代表创建对象的动作 2:接口名称就是匿名内部类需要实现那个接口 3:{。。。。。}这才是匿名内部类的内容 另外还要注意几点问题 1:匿名内部类,在创建对象的时候,只能使用唯一一次, 如果希望多次创建对象,而且类的内容一样的话,那么就必须使用单独定义的实现类了。 2:匿名对象,在【调用方法】的时候,只能调用唯一一次。 如果希望同一个对象,调用多次方法,那么必须给对象取个名字。 3:匿名内部类是省略了[实现类/子类名称],但是匿名对象是省略了[对象名称] 强调:匿名内部类和匿名对象不是一回事!!!!
public interface MyInterface {
public abstract void methodA();//抽象方法
public abstract void methodB();//抽象方法
}
public class MyInterfaceImplement implements MyInterface{
@Override
public void methodA() {
System.out.println("实现类覆盖重写了方法A");
}
@Override
public void methodB() {
System.out.println("实现类覆盖重写了方法B");
}
}
public class DemoMain {
public static void main(String[] args) {
// MyInterface myInterfaceImplement= new MyInterfaceImplement();//右边是实现类左边是接口
// myInterfaceImplement.methodInterface();
//使用匿名内部类,但不是匿名对象,对象名就是numA
MyInterface numA = new MyInterface() {
@Override
public void methodA() {
System.out.println("匿名内部类实现了AAA");
}
@Override
public void methodB() {
System.out.println("匿名内部类实现了BBB");
}
};
numA.methodA();
numA.methodB();
System.out.println("====================");
// 使用匿名内部类,而且省略了对象名称,也就时匿名对象
new MyInterface() {
@Override
public void methodA() {
System.out.println("匿名内部类实现了AAA--a");
}
@Override
public void methodB() {
System.out.println("匿名内部类实现了BBB--b");
}
}.methodA();
//因为匿名对象无法调用第二次方法,所以需要在创建一个匿名内部类的匿名对象。
new MyInterface() {
@Override
public void methodA() {
System.out.println("匿名内部类实现了AAA--a");
}
@Override
public void methodB() {
System.out.println("匿名内部类实现了BBB--b");
}
}.methodB();
}
}