java内部类
如果一个事物的内部包含另外一个事物,那么这就是一个类内部包含另一个类。
例:身体与心脏,,汽车与发动机
内部类的分类
- 成员内部类
- 局部内部类(包含匿名内部类)
1.成员内部类
格式:
修饰符 class 类名称{
修饰符 class 类名称{
//...
}
//...
}
注意事项:内用外,随意访问(小用大);外用内,一定需要借助内部类对象。
package package12.Demo02InnerClass;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 15:34 2021/9/29
* @Modified By:
*/
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("外部类方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
如何使用成员内部类?
两种方式:
- 在外部类的方法当中使用内部类,然后在main方法只是调用外部类的方法。【间接方式】
package package12.Demo02InnerClass;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 15:34 2021/9/29
* @Modified By:
*/
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("外部类方法");
Heart heart = new Heart();
heart.beat();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package package12.Demo02InnerClass;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 15:29 2021/9/29
* @Modified By:
*/
public class Demo01InnerClass {
public static void main(String[] args) {
//外部类对象
Body body = new Body();
//通过外部类对象,调用外部类方法,里面间接使用内部类Heart
body.methodBody();
}
}
2.直接方式:公式:
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
package package12.Demo02InnerClass;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 15:29 2021/9/29
* @Modified By:
*/
public class Demo01InnerClass {
public static void main(String[] args) {
//按照公式来写:
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}
1.1内部类的同名变量访问
如果出现了重名现象,那么格式是:外部类名称.this.外部类成员变量名
2.局部内部类定义
如果一个类定义在一个方法内部,那么这就是一个局部内部类
“局部”:只有当前所属的方法才能调用他,出了这个方法外面就不能用了
格式:
修饰符 class 外部类名称 {
修饰符 返回值类型 外部类方法名称 (参数列表){
class 局部内部类名称 {
//...
}
}
}
小结一下类当中的时候,权限修饰符:
- 外部类: public/(default)
- 成员内部类:public/protected/(default)/private
- 局部内部类:什么都不能写
package package12.Demo03InnerClass;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 19:35 2021/9/29
* @Modified By:
*/
public class Outer {
public void methodOuter(){
class Inner{//局部内部类
int num = 10;
public void methodInner(){
System.out.println(num);//10;
}
}
Inner inner = new Inner();
inner.methodInner();
}
}
package package12.Demo03InnerClass;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 20:50 2021/9/29
* @Modified By:
*/
public class DemoMain {
public static void main(String[] args) {
Outer obj = new Outer();
obj.methodOuter();
}
}
3.局部内部类的final问题
局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】
从java8开始,只要局部变量事实不变,,那么final关键字可以省略
原因:
- new 出来的对象在堆内存中。
- 局部变量是跟着方法走的,是在栈内存当中
- 方法运行结束之后,立刻出栈,局部变量就会立刻消失
- new出来的对象会在堆当中持续存在,直到垃圾回收消失-
4.匿名内部类
如果接口 的实现类(或者是父类的子类)只需要使用唯一的一次,那么这种情况下就可以省略掉该类的定义,而改为使用 【匿名内部类】。
匿名内部类的定义格式:
接口名称 对象名 = new 接口名称(){
// 覆盖重写所有的抽象方法
}
对格式进行解析:new 接口名称(){...}
:
- new代表创建对象的动作
- 接口名称就是匿名内部类需要实现哪个接口
{...}
这才是匿名内部类的内容
另外还需要注意几点问题:
- 匿名内部类使用场景:匿名内部类在创建对象的时候只能使用一次,如果希望多次创建对象,而且希望内容一样的话,那么必须必须使用单独定义的实现类
// MyInterface obj1 = new MyInterface() ;//错误写法,想要使用该接口,必须重新使用匿名内部类编写
MyInterface obj1 = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了抽象方法");
}
};
obj1.method();
- 匿名对象,在调用方法的时候只能调用唯一的一次。如果希望同一个对象,调用多次方法,那么必须给对象起名字
- 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】**强调:**匿名内部类和匿名对象不是一回事
Demo.java
package package12.Demo04;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 22:22 2021/9/29
* @Modified By:
*/
public class DemoMain {
public static void main(String[] args) {
/*MyInterface impl = new MyInterfaceImpl();
impl.method();*///一般方法
//匿名内部类方法,但不是匿名对象,对象名称就叫objA
MyInterface objA = new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了抽象方法,111-A");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了抽象方法,222-A");
}
};
objA.method1();
objA.method2();
System.out.println("========");
// MyInterface objB = new MyInterface() ;//错误写法,想要使用该接口,必须重新使用匿名内部类编写
MyInterface objB = new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了抽象方法,111-B");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了抽象方法,222-B");
}
};
objB.method1();
objB.method2();
System.out.println("========");
//使用了匿名内部类,而且省略了对象名称,也是匿名对象
new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了抽象方法,111-B");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了抽象方法,222-B");
}
}.method1();
//因为匿名对象无法调用第二次方法,所以需要在创建一个匿名内部类的匿名对象
new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了抽象方法,111-B");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了抽象方法,222-B");
}
}.method2();
}
}
MyInterface.java
package package12.Demo04;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 22:20 2021/9/29
* @Modified By:
*/
public interface MyInterface {
public abstract void method1();//抽象方法
public abstract void method2();//抽象方法
}
MyInterfaceImpl.java
package package12.Demo04;
/**
* @Author:Fwh
* @Description:
* @Date:Creat in 22:21 2021/9/29
* @Modified By:
*/
public class MyInterfaceImpl implements MyInterface {
@Override
public void method1() {
System.out.println("实现类覆盖重写了方法,111");
}
@Override
public void method2() {
System.out.println("实现类覆盖重写了方法,222");
}
}