1.内部类
(1)匿名内部类(重要)
匿名对象:没有引用指向这个对象
匿名内部类:没有名字的一个内部类
作用:简化一些没有类本身作用,只为了重写一些抽象方法,匿名内部类就可以简化这种实现类。
上层:子类->接口|抽象父类
//实例代码-匿名内部类
public class Class007_Outer {
public static void main(String[] args) {
//创建 实现类对象调用重写后的抽象方法(简化前的写法)
Demo demo = new Demo();
demo..smoking();
//匿名内部类(三种方式)
//1. 匿名内部类对象 : 没有引用指向的匿名对象 :只能在当前行使用一次
//创建一个Smoke接口的一个没有名字的实现类(匿名内部类)的对象
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.匿名内部类对象作为实参传递
//创建一个Smoke接口的一个没有名字的实现类(匿名内部类)的对象
test( new Smoke(){
@Override
public void smoking() {
System.out.println("一边吸气一边吸烟");
}
});
//通过匿名 内部类简化子类
//创建一个抽象类Car类的一个没有名字的实现类(匿名内部类)的对象
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("一边呲着牙一边吸烟...");
}
}
(2)成员内部类(了解)
一个类定义在外部类的成员位置就为成员内部类,成员内部类具有类的特点,继承,实现,同时作为一个类的成员也具有成员的特点,被成员修饰符修饰。
注:
在成员内部中不能定义静态内容,除了静态常量。
在成员内部类中可以使用外部类中的成员,包括私有的,静态的。
在外部类中可以跟随成员内部类的对象使用成员内部类的成员。
成员内部类的对象需要通过外部类对象构建。
格式:外部类名.内部类类名 引用=new 外部类().new 内部类();
跟随内部类的对象使用内部类的成员,注意访问权限
//实例代码-成员内部类
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();
}
}
(3)静态内部类(了解)
静态内部类:
可以定义静态内容(成员),成员内部类中不可以直接定义静态内容除了静态常量以外
静态内部类中可以直接使用外部类中静态内容,需要通过外部类对象使用外部类中的成员(因为内部类本身是静态的)
外部类中可以直接通过内部类对象使用内部类成员,可以通过内部类的类名使用内部类静态内容
其他类中使用静态内部类中内容:
静态内部类中的静态内容 : 外部类类名.内部类类名.
静态内容 静态内部类中的成员内容: new 外部类类名.内部类类名(); 通过内部类对象调用它成员
//实例代码-静态内部类
public class Class004_Outer {
//成员: 类中方法外
private int i = 1;
private static int j = 5;
//静态内部类
static class Inner{
//成员变量
int a = 1;
//静态变量
static int b = 10;
//成员方法
public void test(){
System.out.println(j);
System.out.println(new Class004_Outer().i);
}
//静态方法
public static void testStatic(){
System.out.println(j);
System.out.println(new Class004_Outer().i);
}
}
void outer(){
//静态内部类对象
Inner in = new Inner();
System.out.println(in.a);
System.out.println(in.b);
System.out.println(Inner.b);
Inner.testStatic();
in.test();
}
}
(4)私有内部类
只能在当前外部类中通过内部类对象使用
//实例代码-私有内部类
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);
}
}
(5)局部内部类
(1)不能被成员修饰符等修饰(public,private,protected,static)
(2)局部内部类中不能定义静态内容,除了静态常量
(3)局部内部类中可以直接使用外部类成员,可以使用所在方法中的局部变量
(4)局部内部类指能在当前所在的方法中通过内部类对象使用,其他位置无法使用
(5)在局部内部类中使用了所在方法中的局部变量|形参,这个局部变量会默认被final修饰
jdk8开始默认被final修饰 jdk7及之前需要显示被final修饰
//实例代码-局部内部类
public class Class006_Outer {
//成员位置
private int i = 1;
private static int j = 2;
public void test(){
//局部位置
int c = 1;
//局部内部类
class Inner{
static final int a = 1;
int b = 2;
void inner(){
System.out.println("局部内部类中的成员方法");
System.out.println(c);
System.out.println(i);
System.out.println(j);
}
}
//1.测试所在方法中能够使用局部内部类中的内容
Inner in = new Inner();
System.out.println(in.b);
in.inner();
}
}
2.Lambda表达式(重要)
Lambda表达式是jdk8新增的表达式,它的作用是为了简化匿名内部类对象结构。
前提:函数式接口
函数式接口:只有一个必须被重写的抽象方法的接口
(强制检测是否为函数式接口的方法:在接口位置-@FunctionalInterface)
语法格式:
()->{}
():匹配要重写的抽象方法的参数列表
->:箭头函数 箭头符号lambda符号,具有上下文推导的作用
{}:要重写的抽象方法的方法体
//实例代码-Lambda表达式的应用
public class Class001_Lambda {
public static void main(String[] args) {
//匿名内部类对象
/* Run r = new Run(){
@Override
public void run() {
System.out.println("run....");
}
};*/
//lambda写法1 : ()->{}
/* Run r = ()->{
System.out.println("run....");
};
r.run();*/
//lambda写法2: 当方法体只有一句 ,前后的{}可以省略
/*Run r = ()->System.out.println("跑....");
r.run();*/
//lambda写法3: 当方法具有参数,参数的类型可以省略
/*Run r = (a,b)->System.out.println("跑...."+(a+b));
r.run(1,2);*/
//lambda写法4: 当方法的参数只有一个 ,前后的()可以省略
/*Run r = a -> System.out.println("跑...."+(a));
r.run(1);*/
//lambda写法5: 当方法存放返回值,并且{}中的语句体只有一句,就是return语句,前后的{}与return关键字可以一起省略
Run r = a -> a>0;
r.run(1);
test(new Run() {
@Override
public boolean run(int x) {
return false;
}
});
//注意: 当方法的形参为一个函数式接口,实参可以为lambda表达式
test((i)->{return i>18;});
test(i->i>18);
}
static void test(Run run){
run.run(1);
}
}
//接口
@FunctionalInterface
interface Run{
boolean run(int x);
static void test(){}
}