内部类
概念：定义在类内部的类，可以在类中方法外，也可以在类中方法中
根据定义位置的不同，分为成员内部类和局部内部类
成员内部类又划分为：
普通的成员内部类
静态的成员内部类
私有的成员内部类
另外还有匿名内部类
普通的成员内部类
定义在成员位置上
class 外部类类名 {
class 内部类类名 {
内部类成员；
}
}
说明：1.成员内部类可以直接访问外部类的成员，包括私有成员
2.外部类想要访问内部类成员，需要创建内部类对象
3.外部类以外，要创建内部类对象，必须先创建外部类对象
格式：外部类类名.内部类类名 内部类对象名 = new 外部类类名（）.new 内部类类名（）
或者 外部类类名 外部类对象名 = new 外部类类名（）
外部类类名.内部类类名 内部类对象名 = 外部类对象名.new 内部类类名（）
4.成员内部类中不能定义静态方法，因为成员内部类相当于成员变量，是随着外部类对象的创建而存在，而静态方法在 类加载的时候就会存在。
package com.DaYu;
public class Demo01 {
public static void main(String[] args) {
Computer_1 com = new Computer_1();
Computer_1.Cpu cpu = com.new Cpu();
cpu.run();
Computer_1.Cpu cpu2 = new Computer_1().new Cpu();
cpu2.run();
}
}
class Computer_1 {
private String brand = "联想";
class Cpu {
String cpubrand = "AMD";
public Cpu() {
}
public void run() {
System.out.println(brand + "cpu型号" + cpubrand);
}
}
public Computer_1(){
}
public void show() {
Cpu c = new Cpu();
c.run();
}
}
私有的成员内部类
定义在成员位置上，只是加上修饰符private
class 外部类类名 {
private class 内部类类名 {
内部类成员
}
}
说明：私有的成员内部类，在其他类中，无法创建对象，只能在外部类中定义一个公共的访问方法，在其中创建内部类的对象，从而间接访问内部类的成员。
静态的成员内部类
1、也是一个成员内部类，在成员内部类的前面加上一个static关键字
2、访问特点
（1）成员内部类是外部类的静态成员，所可以通过外部类名的方式直接访问，而不需要创建外部类的对象
（2）静态内部类中的非静态成员，需要将所在的内部类对象创建出来之后，才能被访问
（3）一个类是否需要创建对象，不是取决于该类本身是否为静态，而是取决于类中的成员是否为静态
3、静态成员内部类的对象创建格式：
外部类名.内部类名 内部类对象名 = new 外部类名.内部类名（）；
package com.DaYu;
public class Demo02 {
public static void main(String[] args) {
Computer_3.HardDisk c3 = new Computer_3.HardDisk();
c3.show();
System.out.println(Computer_3.age);
System.out.println(Computer_3.HardDisk.romSize);
}
}
class Computer_3 {
private String brand = "神舟";
static int age;
static class HardDisk {
String Hardbrand = "三星";
static String romSize = "500G";
public HardDisk() {
}
public void show() {
System.out.println(Hardbrand + romSize);
}
}
}
局部内部类
1、定义在方法中的类
2、局部内部类的访问说明
方法中的局部变量，外界都不能访问到
所以方法中定义的内部类，外界也没有办法访问到
3、解决方式
在方法内部，创建内部类的对象，访问内部类中的成员
外界调用局部内部类所在的方法，间接的创建局部内部类的对象，间接访问局部内部类中的成员
注意：局部内部类在使用方法中定义的局部变量的时候，默认加上了final，不能进行二次赋值
package com.DaYu;
public class Demo03 {
public static void main(String[] args) {
Computer_4 com = new Computer_4();
com.lookMovie();
System.out.println();
}
}
class Computer_4 {
private String brand = "华硕";
public Computer_4() {
super();
}
public void lookMovie() {
final String movieName = "战狼";
class DisPlay {
String tbrand = "TCL";
public DisPlay() {
super();
}
public void show() {
brand = "";
System.out.println(brand +"不要打扰我，我正在使用" + tbrand + "显示器看" + movieName);
}
}
DisPlay dis = new DisPlay();
dis.show();
}
public void test() {
}
}
匿名内部类
1、没有名字的内部类
2、匿名内部类的使用前提：
必须继承一个类或者实现一个接口！！！
3、格式：
new 父类类名或者接口名(){
父类方法的实现或者接口内容的实现；
};
4、本质：
匿名内部类就是创建了一个类或接口的子类对象
package com.DaYu;
public class Demo01 {
public static void main(String[] args) {
new MyFu() {
@Override
public void test() {
System.out.println("匿名内部类");
}
}test();
MyInter mi = new MyInter() {
@Override
public void inte_2() {
System.out.println("inte_2");
}
@Override
public void inte_1() {
System.out.println("Inte_1");
}
};
mi.inte_1();
mi.inte_2();
new MyInter() {
@Override
public void inte_2() {
System.out.println("inte_2");
}
@Override
public void inte_1() {
System.out.println("Inte_1");
}
}.inte_1();
}
}
interface MyInter {
public abstract void inte_1();
public abstract void inte_2();
}
abstract class MyFu{
public abstract void test();
}
package com.DaYu;
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数 系统会为你分配一位老师");
int input = scanner.nextInt();
Teacher teacher = School.getTeacher(input);
teacher.teach();
}
}
class School {
public static Teacher getTeacher(int a) {
if (a % 2 == 0) {
return new Teacher() {
@Override
public void teach() {
System.out.println("教java");
}
};
} else {
return new Teacher() {
@Override
public void teach() {
System.out.println("抽烟喝酒烫头");
}
};
}
}
}
interface Teacher {
void teach();
}