跟日记本一起学JAVA！相信你可以的，加油~
本课闯关内容：1.照猫画虎（0/3）
2.基础知识(0/3）
这里的基础知识的编号与照猫画虎的编号不是对应的，而是上面的基础知识对应着下面的照猫画虎代码。
有补充或者有错误我会在评论区里发或...
建议你们在电脑上看。
我之后再更新JAVA系列要2月之后了，因为我们放暑假了，下一个学期我们继续学习JAVA。
———————————————————————————————————————————
基础知识1：
内部类
一、概念
1.内部类：定义在一个类内部的类。
2.内部类编译之后生成独立的 .class 文件，命名： 外部类类名$内部类类名.class内部类可以直接3.使用外部类私有成员，从而不破坏外部类的封装性。
4.内部类的分类：成员内部类、静态内部类、局部内部类、匿名内部类。
二、内部类的分类
1. 成员内部类：类比于实例变量
（1）位置：定义在类以内，方法以外。
（2）成员内部类对象的创建，必须依赖于外部类的对象而创建（语法）：
Outer o = new Outer(); // 外部类的对象
Outer.Inner i = o.new Inner(); // 内部类的对象
（3）(语法)
外部类的当前对象：外部类类名.this
外部类类名.this.属性名 ->访问外部类的属性
外部类类名.this.成员方法名(参数) ; ---->调用外部类的成员方法
（4）成员内部类中不能定义静态成员(静态属性和静态方法)
2. 静态内部类：类比于静态变量
（1）位置：定义在类以内，方法以外，同时被 static 修饰
（2）静态内部类中可以定义实例变量，也可以定义静态变量
（3）创建静态内部类的对象，只需要依赖于外部类的类名即可（语法）：
Outer.Inner i = new Outer.Inner();
（4）(语法）
访问静态内部类的静态成员时，可以直接通过 ：
外部类类名.静态内部类类名 进行访问。
外部类类名.静态内部类类名.静态属性名
外部类类名.静态内部类类名.静态方法名(实参);
（5）静态内部类只能访问外部类的静态成员（静态属性和静态的方法）
3.局部内部类：类比于局部变量
（1）位置：定义在方法内部
（2）局部内部类对象的创建，必须在定义它的方法内部创建，并且在类的定义位置后面完成对象的创建
（3）局部内部类的方法中可以访问定义它的方法内部的局部变量，但是要求局部变量必须 被 final 修饰。
注意：JDK8.0及以上版本，编译器编译时，如果检测到局部变量被局部内部类中方法访问，则默认为此局部变量前面 final ，这种技术被称为语法糖。
照猫画虎1：
package demo;
public class Test1{
public static void main(String[]args){
}
}
//外部类
class ClassA{
//成员内部类：定义在一个类的里面
class ClassB{
}
}
class ClassC{
//静态内部类：定义在外部类的里面，同时被static修饰
static class ClassD{
}
}
class ClassE{
int a=5;//成员变量
public void test(){
int m=6;//局部变量
//局部内部类
class ClassF{
}
}
}
//这些类的创建
（因为没有写要输出的代码，所以没有输出）
输出：
基础知识2：
- 匿名内部类：是一个特殊的局部内部类
（1）匿名内部类的定义必须继承一个类或是实现一个接口
（2）基于一个匿名内部类只能创建该类的一个对象，并且匿名内部类的定义和对象的创建一起完成。
（3）语法（引用名：你随便起名，你之后要引用的时候用此名引用）：
接口名 引用名 = new 接口名(){
// 接口中需要实现的方法
};
(4) 匿名内部类的优缺点：
a.优点：减小代码量，让编程思路连贯。
b.缺点：可读性低。
案例：
照猫画虎2：
package demo;
public class Test2{
public static void main(String[]args){
//匿名内部类
IA ia =new IA(){
public void ma(){
System.out.println("ma...");
}
public int mb(int a,int b){
return a+b;
}
};
ia.ma();//ma....
System.out.println(ia.mb(4,7));//11
}
}
//接口
interface IA{
void ma();
int mb(int a,int b );
}
输出：
ma...
11
基础知识3：
三、Lambda表达式
- Lambda表达式：对匿名内部类的进一步简化，大大的减少了代码的冗余
- Lambda表达式应用场景：对函数式接口的实现
(接口中有且只有一个抽象方法称为函数式接口)
3.语法（语法中的箭头，没错是必写的！！！大括号后有一个分号“；”）：
接口名 引用名 =（数据类型 参数名，数据类型 参数名）->{
//方法的实现部分
};
（1）没有参数，没有返回值（语法）：
接口名 引用名 =（）->{
//方法的实现部分
};
注意：如果{}中仅有1条语句时，{}可以省略
（2）有参数，没有返回值（语法）：
接口名 引用名 =（数据类型 参数名，数据类型 参数名）->{
//方法的实现部分
}；
注意：（）中的数据类型可以省略(如果你下面有代码为接口或者为一个父类（继承)，在其中的形参，那么在上面的Lambda表达式的（）要与下面一样的形参名，没错！！！它自己会找。）
eg: IB ib2 = (x,y)->
System.out.println(x+y);
ib2.mi(3.8,9.8);
（3）有返回值，有参数（语法）：
接口名 引用名 =（数据类型 参数名，数据类型 参数名）->{
//方法的实现部分
return 值；
}；
注意：{}中只有一条return语句时，{}和return可以一起省略
eg:
IC ic2 =(m,n)->m+n;
interface IC{
int m2(int a,int b);
}
4. Lambda表达的优缺点
(1)优点：简化代码，降低代码的冗余性。
(2)缺点：可读性低
idea的部分快捷键
psvm ->enter即可
sout ->enter System.out.println();
照猫画虎3：
package demo;
public class Test3{
public static void main(String[]args){
IB ib =()->{
System.out.println("ma...");
};
ib.ma();
IC ic = (int a,int b)->{
System.out.println(a+"+"+b+"="+(a+b));
};
ic.mc(1,2);
ID id = (a,b)->{
if(a>b){
return true;
}else return false;
};
System.out.println(id.md(4,8));//false
}
}
//函数式接口：在接口中有且只有一个抽象方法
interface IB{
void ma();
}
interface IC{
void mc(int a,int b);
}
interface ID{
boolean md(int a,int b);
}
函数式接口：在接口中有且只有一个抽象方法。
输出：
ma...
1+2=3
false
跟我一步步学，慢慢走。
未完待续。。。。