非静态内部类
非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限, 通常被称为内部类。
类中定义类
当一类中的成员,作为另外一种事物的时候,这个成员就可以定义为内部类
分类:
成员内部类
静态内部类
私有内部类
局部内部类
匿名内部类 ***
Lambda表达式 *****
由于内部类嵌套在外部类中,因此必须首先实例化外部类,然后创建内部类的对象来实现。
public class Class001_Outer {//外类
//成员: 类中方法外
private int i = 1;
private static int j = 5;
//成员内部类
class Inner{ 内部类
private int a = 10;
public void testInner(){
System.out.println("成员内部类中的成员方法");
System.out.println(i);
System.out.println(j);
//outer();
}
}
public void outer(){
System.out.println("成员方法");
Inner in = new Inner();
System.out.println(in.a);
in.testInner();
}
}
私有的内部类
内部类可以使用 private 或 protected 来修饰,如果你不希望内部类被外部类访问可以使用 private 修饰符:
私有内部类
只能在当前外部类中通过内部类对象使用
public class Class005_Outer {
private int i = 1;
private static int j = 2;
//私有的
private class Inner{
int a = 2;
static final int B = 10;
void test(){
System.out.println("私有内部类中的成员方法");
System.out.println(i);
System.out.println(j);
}
}
void outer(){
System.out.println("外部类中的成员方法");
Inner in = new Inner();
System.out.println(in.a);
System.out.println(in.B);
System.out.println(Inner.B);
}
}
静态内部类
静态内部类可以使用 static 关键字定义,静态内部类我们不需要创建外部类来访问,可以直接访问它:
class OuterClass {
int x = 10;
static class InnerClass {
int y = 5;
}
}
public class MyMainClass {
public static void main(String[] args) {
OuterClass.InnerClass myInner = new OuterClass.InnerClass();
System.out.println(myInner.y);
}
}
以上实例执行输出结果为:5
注意:静态内部类无法访问外部类的成员。
匿名内部类
作用: 用来简化没有本身自己作用的实现类|子类
上层 : 接口 | 抽象类
public class Class007_Outer {
public static void main(String[] args) {
//匿名对象 : 只能在当前行使用一次
new String();
//创建 实现类对象调用重写后的抽象方法
new Demo().smoking();
//匿名内部类
//1) 匿名内部类对象 : 没有引用指向的匿名对象 :只能在当前行使用一次
new Smoke() {//实现类的类体
@Override
public void smoking() {
System.out.println("一边哈哈笑一边吸烟...");
}
}.smoking();
//2. 引用指向的匿名内部类对象 : 通过引用后续使用多次
Smoke s = new Smoke(){
@Override
public void smoking() {
System.out.println("一边吸气一边吸烟");
}
};
s.smoking();
s.smoking();
//3.匿名内部类对象作为实参传递
test( new Smoke(){
@Override
public void smoking() {
System.out.println("一边吸气一边吸烟");
}
});
//通过匿名 内部类简化子类
Car car = new Car(){
@Override
void run() {
System.out.println("run....");
}
};
car.run();
}
static void test(Smoke smoke){
smoke.smoking();
}
}
//抽象类
abstract class Car{
abstract void run();
}
//接口
interface Smoke{
void smoking();
}
//实现类 ,重写抽象方法
class Demo implements Smoke{
@Override
public void smoking() {
System.out.println("一边呲着牙一边吸烟...");
}
}
匿名内部类可以使你的代码更加简洁,你可以在定义一个类的同时对其进行实例化。它与局部类很相似,不同的是它没有类名,如果某个局部类你只需要用一次,那么你就可以使用匿名内部类
重点 重点
Lambda 表达式 *****
jdk8新增lambda表达式
作用: 为了简化匿名内部类对象
前提: 函数式接口
函数式接口 : 只有一个必须被重写的抽象方法的接口
强制检测是否为函数式接口:
注解: @FunctionalInterface
语法:
()->{}
() : 匹配要重写的抽象方法的参数列表
-> : 箭头函数 箭头符号
{} : 要重写的抽象方法的方法体