Java内部类

1.什么是内部类

​ 在一个类中定义一个类,类中的类就是内部类

​ 如: A类中定义了一个类B, 类B就是类A的内部类

2.内部类的分类

​ 成员内部类 局部内部类 匿名内部类

3.成员内部类

​ 将类定义在类中的成员位置,这种内部类叫做成员内部类

//定义一个外部类
public class Outer {
	private int num = 10;
	//成员内部类也属于外部类的一部分
	private class Inner{
		private int score = 60;
		private void show() {
			System.out.println("内部类输出外部类中的私有属性num = "+num);
		}
	}
	
	public void print() {
		System.out.println("是否能获取到内部类的成员?");
		//因为内部类是一个类,与方法不同是需要实例化之后才可以使用
		Inner inner = new Inner();
		//因为内部类在同一个类中,所以可以访问内部类中的私有内容
		System.out.println("内部类中的私有属性:"+inner.score);
		inner.show();
	}
}

public class Demo {

	public static void main(String[] args) {
		Outer out = new Outer();
		out.print();
		//如何使用内部类
		//内部类是一个类,无法直接被使用,需要创建对象之后才可以使用
		//创建内部类对象的方式:  外部类.内部类 名称 = 外部对象.new 内部类();
		//Outer.Inner inner = out.new Inner();
		//inner.show();
	}
}

推荐方案:

​ 将一个类,设计为内部类的目的,大多数都是不想让外部直接访问,所以将内部了设置为私有的,私有化之后为其提供一个可以被外界访问的方法,在方法内部创建内部类的实例对象

4.局部内部类

​ 在方法中定义的类叫做局部内部类

​ 局部内部类的访问特点:

​ 局部内部类在方法之外无法访问,需要在方法中创建对象并使用

​ 内部类可以访问外部类成员

//局部内部类,定在方法中的类
public class Outer {

	private int num = 20;
	
	public void method() {
		int num2 = 10;
		//局部内部类只有在方法中访问,所以不需要访问修饰符
		class Inner{
			public void show() {
				System.out.println("局部内部类访问外部类私有成员:num = "+num);
				System.out.println("局部内部类访问方法中的变量: num2 = "+num2);
			}
		}
		//局部内部类方法之外无法访问,只能在方法中创建使用
		Inner inner = new Inner();
		inner.show();
	}
}

public class Dmeo {

	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.method();
	}
}

5.匿名内部类(重点)

​ 匿名内部类: 这种类是属于一种应用内部类,在一个类中需要使用另一个接口或抽象类时,直接实现的类,且没有名称

​ 匿名内部类的前提: 存在一个类或接口,这里的类可以是具体类,也可以是抽象类

​ 匿名内部类的格式: new 类名(){ 重写方法 } new 接口(){重写方法} {重写方法}—这一块就是内部类

​ 匿名内部类的本质: 是一个继承了该类或者实现了该接口的子类匿名对象

//使用interface修饰的叫做接口
public interface USBInterface {
	//接口中只有静态常量,static和final是默认提供的
	public static final int WEEK=7;
	//抽象方法,USB提供服务方法
	public abstract void service();
}

public class Demo {

	public static void main(String[] args) {
		//创建接口的对象,但是接口无法实例化,在创建对象的时候,会出现匿名子类,实际创建的是匿名子类对象
		USBInterface usb = new USBInterface() {
			@Override
			public void service() {
				System.out.println("匿名子类重写接口方法");
			}
		};
		//调用usb对象的service方法
		usb.service();
		
		//直接创建匿名对象,且调用对象中的方法
		new USBInterface() {
			@Override
			public void service() {
				System.out.println("匿名子类再次重写");
			}
		}.service();
	}
}

匿名内部类在开发过程中的使用(掌握)

​ 当发现某个方法需要接口或抽象类子类对象,我们可以传递一个子类对象到方法中去,使用匿名对象的方式简化代码

​ 猫狗跳高, 跳高接口 ,操作类

//使用interface修饰的叫做接口
public interface Jump {
	//抽象方法,跳高功能
	public void jump();
}
//子类
public class Dog implements Jump {

	@Override
	public void jump() {
		System.out.println("狗仔可以跳高了.....");
	}
}

//操作类
public class JumpOperator {

	public void method(Jump j) {
		//调用跳高功能
		j.jump();
	}
}

//测试类
public class Demo {

	public static void main(String[] args) {
		JumpOperator jo = new JumpOperator();
		//狗跳高 1.创建狗跳高对象   2.将狗对象放入跳高计算对象
		Jump j = new Dog();
		jo.method(j);
		//猫跳高  1.创建猫跳高   2.将猫对象放入跳高计算对象
		j = new Cat();
		jo.method(j);
		
		
		System.out.println("==============简化代码==============");
		//直接使用匿名内部类对象作为参数传递,1.减少子类的编写   2.减少对象的创建
		jo.method(new Jump() {
			@Override
			public void jump() {
				System.out.println("狗仔可以跳高了....");
			}
		});
		
		jo.method(new Jump() {
			@Override
			public void jump() {
				System.out.println("喵咪可以跳高了.....");
			}
		});
	}
}