目录
1.概述:
2.内部类之一:静态内部类
3.内部类之二:成员内部类
4.内部类之三:局部内部类
5.内部类之四:匿名内部类
1.概述:
内部类就是定义在一个类里面的类，里面的类可以理解成(寄生)。
2.内部类的使用场景、作用：
①当一个事务的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计；
②内部类通常可以方便访问外部类的成员，包括私有的成员；
③内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。
3.内部类的分类
①静态内部类
②成员内部类
③局部内部类
④匿名内部类
2.内部类之一:静态内部类
1.概述:
有static修饰，属于外部类本身；
它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已；
2.静态内部类创建对象的格式:
3.静态内部类的访问扩展:
①静态内部类是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
②静态内部类是否可以直接访问外部类的实例成员？
不可以，外部类的实例成员必须用外部类对象访问。
4.代码演示:
外部类:
/**
* 外部类
*/
public class Outer {
/**
* 静态成员内部类
* 格式:外部类名.内部类名 对象名 = new 外部类名.内部类构造器
* 范例: Outer.inner in = new Outer.inner();
* 静态内部类可以直接访问外部类静态成员，因为外部类的静态成员只有一份可以被共享访问
* 静态内部类不可以直接访问外部类实例成员，因为外部类的实例成员必须用外部类对象访问（可以new一个对象间接访问）
*/
public static class Inner{
public static int num = 111;
private String hobby;
private String name;
private int age;
public static String schoolName;
public Inner() {
}
public Inner(String name, int age) {
this.name = name;
this.age = age;
}
public void show(){System.out.println("名称 ："+name);}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
public static String getSchoolName() {return schoolName;}
public static void setSchoolName(String schoolName) {Inner.schoolName = schoolName;}
}
}main类:
public class Test {
public static void main(String[] args) {
Outer.Inner in = new Outer.Inner();
in.setName("张三");
in.show();
Outer.Inner in2 = new Outer().new Inner();
in2.show2();
Outer.Inner.test();
System.out.println("----------------");
Outer.Inner in3 = new Outer("爱听课").new Inner();
}
}5.总结:
①如果一个类中包含了一个完整的成分，如汽车中的发动机类；
②特点、使用与普通类是一样的，类的成分它都有，只是位置在别人里面而已；
③可以直接访问外部类的静态成员，不能直接访问外部类的实例成员；
④注意:开发中实际上用的还是比较少。
3.内部类之二:成员内部类
1.概述:
①无static修饰，属于外部类的对象；
②JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员了；
2.成员内部类创建对象的格式:
3.代码演示:
外部类:
/**
* 外部类
*/
public class Outer {
/**
* 成员内部类：不能加static修饰，属于外部类对象
*格式：外部类名.内部类名 in = new Outer().new inner();
* 范例:Outer.inner in = new Outer().new inner();
* 成员内部类可以直接访问外部类静态成员，因为外部类的静态成员只有一份可以被共享访问
* 成员内部类可以直接访问外部类实例成员，因为必须要先有外部类，才能有成员内部类对象。
*/
public static class Inner{
private String name;
private int age;
public static int a =100;
//构造方法
public static void test(){
System.out.println(a);
}
public void show (){
System.out.println("名称："+name);
System.out.println("数量："+name);
System.out.println("爱好："+hobby);
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}
}main类:
public class Test {
public static void main(String[] args) {
Outer.Inner in = new Outer.Inner();
in.setName("张三");
in.show();
Outer.Inner in2 = new Outer.Inner();
in2.show();
Outer.Inner.test();
System.out.println("----------------");
Outer.Inner in3 = new Outer("爱听课").new Inner();
in3.show();
}
}4.成员内部类的访问扩展:
①成员内部类是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
②成员内部类是否可以直接访问外部类的实例成员？
可以，因为必须现有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。
5.总结:
①成员内部类是什么样的、有什么特点？
无static修饰，属于外部类的对象；
可以直接访问外部类的静态成员，实例方法中可以直接访问外部类的实例成员；
②成员内部类如何创建对象？
外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器()；
6.注意:
在成员内部类中访问所在外部类对象。
格式:外部类名.this。
4.内部类之三:局部内部类
1.概述:
①局部内部类放在方法、代码块、构造器等执行体中；
②局部内部类的类文件名为:外部类$N内部类.class。
2.代码演示:
public class Test {
static{
class Dog{
}
abstract class Animal{//定义抽象类
}
interface SportManInter{//定义接口
}
}
public static void main(String[] args) {
/**
* 局部内部类
*/
class cat{
private String name;
public int onlineNumber = 100;
public String getName(String s) {
return name;
}
public void setName(String name) {
this.name = name;
}
}
cat c = new cat();
System.out.println(c.getName("叮当猫~~"));5.内部类之四:匿名内部类
1.概述:
本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。
2.作用:
方便创建子类对象，最终目的是为了简化代码编写。
3.格式:
例如:
4.特点:
-
匿名内部类是一个没有名字的内部类；
-
匿名内部类写出来就会产生一个匿名内部类对象；
-
匿名内部类的对象类型相当于是当前new的那个的类型的子类对象；
-
匿名内部类无需创建子类，方便简化代码；
5.案例:匿名内部类在开发中的使用形式。
需求: 某学校让老师，学生，运动员一起参加游泳比赛。
/**
* 匿名内部类:可以作为方法的实际参数传输~~
*/
public class Test {
public static void main(String[] args) {
Swimming s = new Swimming() {
@Override
public void swim() {
System.out.println("学生快乐的自由游泳~~");
}
};
go(s);
System.out.println("--------------");
go(new Swimming() {
@Override
public void swim() {
System.out.println("");
}
});
go(s);
}
public static void go(Swimming s){
System.out.println("开始————");
s.swim();
System.out.println("结束------");
}
}
//游泳接口
interface Swimming{
void swim();
}使用总结: 匿名内部类可以作为方法的实际参数进行传输。
6.Lambda
①Lambda :简化匿名内部类的代码写法
②注意 :Lambda只能简化函数接口的匿名内部类的写法形式
③Lambda只能简化函数接口：首先必须是接口，其次接口中有且仅有一个抽象方法的形式
④Lambda表达式的省略规则:
-
参数类型可以省略；
-
如果只有一个参数，参数类型可以省略，（）也可以省略，同时省略分号；
-
如果Lambda表达式的方法体代码只有一行代码，可以省略大括号不写。此时如果这行代码是return语句，必须省略return不写，";"也可以省略；
public class Lambda {
public static void main(String[] args) {
swimming s1 =()->{
System.out.println("老师游泳很快~~");
};
go(s1);
System.out.println("=======================");
go(new swimming() {
@Override
public void swim() {
System.out.println("学生游泳很开心~~");
}
});
}
public static void go(swimming s){
System.out.println("开始");
s.swim();
System.out.println("结束");
}
}
interface swimming{
void swim();
}7.案例:匿名内部类在开发中的真实使用场景。
需求: 给按钮绑定点击事件
/**
* 通过GUI，理解匿名内部类的真实使用场景
*/
public class Test {
public static void main(String[] args) {
//1.创建窗口
JFrame win = new JFrame("登陆界面");
JPanel panel = new JPanel();
win.add(panel);
//创建一个按钮对象
JButton btn = new JButton("登录");
//讲解匿名内部类的使用
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(win,"点我一下，说明爱我！");
}
});
//简化代码
btn.addActionListener(e -> JOptionPane.showMessageDialog(win,"点我一下，告诉我你在！"));
//3.把按钮对象添加到窗口上展示
win.add(btn);
//4.展示窗口
win.setSize(400,300);
win.setLocationRelativeTo(null);
win.setVisible(true);
}
}使用总结:
①开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。
②匿名内部类的代码可以实现代码的进一步简化。
