疯狂java ee讲义下载_【Java】-NO.16.EBook.4.Java.1.004-【疯狂Java讲义第3版 李刚】- 内部类...

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);

}