1.0.0 Summary
Tittle：【Java】-NO.16.EBook.4.Java.1.004-【疯狂Java讲义第3版 李刚】- 内部类
Style：EBook
Series：Java
Since：2017-09-04
End：....
Total Hours：...
Degree Of Diffculty：2
Degree Of Mastery：2
Practical Level：2
Desired Goal：2
Archieve Goal：....
Gerneral Evaluation：...
Writer:kingdelee
Related Links：
http://www.cnblogs.com/kingdelee/
package com.lee.test.java.ebook.crazy_java.u_6_oop_2.c_6_7_inner_test;
// 1. 内部类提供了更好的封装
// 2. 在内部类，访问内部类非静态变量用 this.var，访问外部类非静态变量用 Out.this.var
// 3. 在外部类，访问内部类非静态变量用 new Inner().var
// 4. 在外部类，静态的方法不能调用非静态类
// 5. 在非静态内部类，不能存在静态声明
// 6. 外部类访问静态内部类的静态成员，StaticInner.staticVar
// 6.1 外部类访问静态内部类的非静态成员，new StaticInner().var
// 7. 静态内部类无法访问外部类的非静态成员
// 8. 在外部类的外部构造外部类的内部类实例 Out.In in = new Out().new In();
// 8.1 等价于 Out.In in1; Out out = new Out(); in1 = out.new In();
// 9. 子类继承外部类的非静态内部类时，子类构造器必须显式的调用父类的构造器
// 9.1 子类可以直接继承外部类的静态内部类，故优先使用静态内部类会更加方便
// 10. 在外部类的外部构造静态内部类实例 Out.In in = new Out.In();
// 10.1 等价于 Out.staticIn staticIn1; staticIn1 = new Out.staticIn();
// 11. 局部内部类，即定义在方法中的类，Out$NInner.class规则生成class文件：Cow.class Cow$1Inner.class Cow$1InnerSub.class
// 12.1 匿名内部类lambada无参版，接口必须是有唯一抽象方法（类方法、默认方法随意），即函数式接口 @FunctionInterface 下同
// 12.2 匿名内部类lambada有参版，@FunctionInterface
// 12.3 匿名内部类lambada有参版 有返回值 缩略return，@FunctionInterface
// 12.4 匿名内部类lambada有参版，有返回值 显式return，@FunctionInterface
// 12.5 匿名
// 12.6 将实现函数式的接口强转
// 12.7 常见的函数式接口 java.util.function
// xxxFunction, apply() 处理 数值 并返回新值
// xxxConsumer, accept() 处理 新值 不返回值
// xxxPredicate, test() 判断 返回boolean
// xxxSupplier, getAsXxx() 按某种逻辑算法 返回值
// 12.8.1 Lambada 未缩减 调用类方法
// 12.8.1.1 Lambada ::方法调用 省略参数，引用类方法 Converter converter1_1 = Integer::getInteger;
// 12.8.2 Lambada 未缩减 调用实例 Converter converter2 = str -> "".indexOf("");
// 12.8.2.1 Lambada ::方法调用 省略参数，引用实例方法 Converter converter2_1 = str -> "".indexOf("");
// 12.8.3 Lambada 未缩减 调用实例 MyTest converter3 = (a1, b, c) -> a1.substring(b, c);
// 12.8.3.1 Lambada ::方法调用 省略参数，第一个参数为调用者，之后的参数为形参传进来 MyTest converter3_1 = String::substring;
// 12.8.4 Lambada ::new 构造参数 Converter converter4 = Integer::new;
public class Cow {
private int weight;
private String color = "white";
public Cow(int weight) {
this.weight = weight;
}
// 内部类提供了更好的封装
private class CowLeg {
private int num;
private String color = "black";
// 5.1 在非静态内部类，不能存在静态声明
// static{
//
// }
// 5.2 在非静态内部类，不能存在静态声明
// private static void t1(){
//
// }
// 5.3 在非静态内部类，不能存在静态声明
// private static int a;
public CowLeg(int num) {
this.num = num;
}
public void printLeg() {
System.out.println("this cow weight:" + weight + ", has leg:" + num);
// 2. 在内部类，访问内部类非静态变量用 this.var，访问外部类非静态变量用 Out.this.var
System.out.println("leg color:" + this.color + ", cow color:" + Cow.this.color);
}
}
// 静态内部类
private static class Life {
private static int num = 5;
private int age;
static {
// 7 编译失败，静态内部类无法访问外部类的非静态成员
// System.out.println(Cow.this.color);
}
}
public void getLife() {
// 6. 外部类访问静态内部类的静态成员，StaticInner.staticVar
System.out.println(Life.num);
// 6.1 外部类访问静态内部类的非静态成员，new StaticInner().var
System.out.println(new Cow(1).color);
}
public void getLegInfo(int num) {
new CowLeg(num).printLeg();
// 3. 在外部类，访问内部类非静态变量用 new Inner().var
System.out.println("inner color:" + new CowLeg(1).color);
}
public static void main(String[] args) {
new Cow(10).getLegInfo(2);
// 4. 编译失败，外部类的静态方法，无法调用非静态的内部类
//new CowLeg(1);
// 8. 在外部类的外部构造非静态内部类实例 Out.In in = new Out().new In();
Out.In in = new Out().new In();
// 8.1 等价于 Out.In in1; Out out = new Out(); in1 = out.new In();
Out.In in1;
Out out = new Out();
in1 = out.new In();
// 10 在外部类的外部构造静态内部类实例 Out.In in = new Out.In();
Out.staticIn staticIn = new Out.staticIn();
// 10.1 等价于
Out.staticIn staticIn1;
staticIn1 = new Out.staticIn();
// 11. 局部内部类，即定义在方法中的类，Out$NInner.class规则生成class文件：Cow.class Cow$1Inner.class Cow$1InnerSub.class
class Inner {
}
class InnerSub extends Inner {
}
// 12. 匿名内部类
new Cow(1).showFace(new Face() {
@Override
public void show() {
System.out.println("show Cow face");
}
});
// 12.1 匿名内部类lambada无参版，接口必须是有唯一抽象方法（类方法、默认方法随意），即函数式接口 @FunctionInterface 下同
new Cow(1).showFace(() -> System.out.println("show Cow face"));
// 12.2 匿名内部类lambada有参版，@FunctionInterface
new Cow(1).drop(num -> System.out.println("drop egg:" + num));
// 12.3 匿名内部类lambada有参版 有返回值 缩略return，@FunctionInterface
Wallet2 w = (int banknote, int coin) -> banknote + coin;
// 12.4 匿名内部类lambada有参版，有返回值 显式return，@FunctionInterface
Wallet wallet = (int[] bb, int[] cc) -> {
int count = 0;
for (int b : bb) {
count += b;
}
for (int c : cc) {
count += c;
}
return count;
};
int[] banknotes = {1, 2, 3};
int[] coins = {1, 2, 3};
int count1 = new Cow(1).count(wallet, banknotes, coins);
// 12.5 匿名 Runnable r = () -> {};
Runnable r = () -> {
};
// 12.6 将实现函数式的接口强转
Object a = (Runnable) () -> {
};
// 12.7 常见的函数式接口 java.util.function
// xxxFunction, apply() 处理 数值 并返回新值
// xxxConsumer, accept() 处理 新值 不返回值
// xxxPredicate, test() 判断 返回boolean
// xxxSupplier, getAsXxx() 按某种逻辑算法 返回值
// 12.8.1 Lambada 未缩减 调用类方法
Converter converter1 = str -> Integer.getInteger(str);
// 12.8.1.1 Lambada ::方法调用 省略参数，引用类方法
Converter converter1_1 = Integer::getInteger;
// 12.8.2 Lambada 未缩减 调用实例
Converter converter2 = str -> "".indexOf("");
// 12.8.2.1 Lambada ::方法调用 省略参数，引用实例方法
Converter converter2_1 = str -> "".indexOf("");
// 12.8.3 Lambada 未缩减 调用实例
MyTest converter3 = (a1, b, c) -> a1.substring(b, c);
// 12.8.3.1 Lambada ::方法调用 省略参数，第一个参数为调用者，之后的参数为形参传进来
MyTest converter3_1 = String::substring;
// 12.8.4 Lambada ::new 构造参数
Converter converter4 = Integer::new;
}
public void showFace(Face face) {
face.show();
}
public void drop(Egg egg) {
egg.show(2);
}
public int count(Wallet wallet, int[] banknotes, int[] coins) {
return wallet.countMoney(banknotes, coins);
}
}
class Out {
class In {
public In() {
System.out.println("in");
}
}
static class staticIn {
public staticIn() {
System.out.println("staticIn");
}
}
}
// 9. 子类继承外部类的非静态内部类时，子类构造器必须显式的调用父类的构造器
class Sub extends Out.In {
public Sub(Out out) {
out.super();
}
}
// 9.1 子类可以直接继承外部类的静态内部类，故优先使用静态内部类会更加方便
class Sub2 extends Out.staticIn {
}
@FunctionalInterface
interface Face {
void show();
}
@FunctionalInterface
interface Egg {
void show(int num);
}
@FunctionalInterface
interface Wallet {
int countMoney(int[] banknotes, int[] coins);
}
@FunctionalInterface
interface Wallet2 {
int countMoney(int banknote, int coin);
}
@FunctionalInterface
interface Converter {
Integer convert(String str);
}
@FunctionalInterface
interface MyTest {
String test(String a, int b, int c);
}