回顾
--------------------------------
class：类成员
构造函数：和类同名，无返回值。可以重载
第一条语句 this()（调自身） 或 super()（调超类构造） 默认是super()，超类无空构造 要super中要指定构造函数的参数。
成员变量：修饰符 private public final
成员函数
静态成员：跟类有关，存在方法区
静态代码块： 类加载时执行
构造代码块：｛｝ 在创建对象时执行，每创建一个对象执行一次
抽象类：用abstract 修饰的类，不能用于创建对象，一定有构造函数
抽象方法：无方法体，用abstract修饰，用途：为了让子类便于实现。只能放在抽象类中。
final:最终的 修饰 类：不能继承
方法：不能重写 不能覆盖
变量：不能重新赋值，为常量
内部类： 定义在类内部的类，可定义在成员位置上
定义在方法中
内部类名存成文件 的格式：
定义在类中：外部类名$内部类名.class
定义在方法中：外部类名$序号内部类名.class
继承：extends
单重继承，可多层继承
JVM
-------------------------------
方法区：
栈区：调整大小 java -Xss
堆区：对象太多了， java -Xms java
-Xmx
=========================================================
接口
: 经编译后也是生成class文件，但是用interfaec修饰的类
----------------------
- 格式：interface{ }
- 成员修饰符是固定的
- 成员变量：public static
final - 成员函数：public abstract 说明接口中的所有方法都是抽象的。
- 发现接口中的成员都是public的
- 成员变量：public static
- 接口的出现将“多继承”通过另一种形式体现出来，即“多实现”
- 接口常用形容词来命名。
接口的特点：
-------------------------------
- 接口是对外暴露的规则
- 接口是程序的功能扩展
- 接口的出现降低耦合性
- 接口可以用来多实现
- 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
- 接口与接口之间可以有继承关系，可以继承多个接口
- 接口的主要用作用是类与类、对象与对象之间的交互问题上
示例：
-------------------------------------------------------
class InterfaceDemo1{
public
static void main(String[] args){
//建立类对象
WomenStar
ws = new WomenStar();
//通过类象象调用方法
ws.white();
ws.rich();
//建立tuhao对象
TuHao
tuhao = new TuHao();
//调用marry方法，传入ws对象，因为ws对象实现了White接口，而tuhao将white作为参数传入了方法，对接成功，所以tuhao对象的marry方法可以直接调用ws对象作为方法的参数。
tuhao.marry(ws);
}
}
//定义一个名字为white的接口
interface White{
//接口中的方法都是抽象的，所以方法无方法体，只有括号
public
void white();
}
//定义一个名字为 Rich 接口
interface Rich{
public
void rich();
}
//类实现接口(接键字implements+接口名)，如果类不是抽象的，在使用接口时，类中必须对接口中的方法进行实现，就算不需人任何方法也要实现一个空方法（实现的方法名要与接口中一致区分大小写）。
//这里分别调用实现了White 和 Rich
接口
class WomenStar
implements White,Rich{
//实现接口中的方法
public
void white(){
System.out.println("---在WomenStar类中对White接口实现White方法---");
}
public
void rich(){
System.out.println("---在WomenStar类中对Rich接口实现rich方法---");
}
}
//定义Tuhao类
class TuHao{
//将接口作为方法的参数传入
public
void marry( White w){
//通过传用的参数类型，调用形参的方法（也就是接口的方法）
w.white();
}
}
class KoreanMan
implements White{
public
void white(){
System.out.println("---在KoreanMan类中对White接口实现White方法---");
}
--------------------------------------------------------
USB:
---------------------------
接口：面向接口编程的优势：
------------
降低耦合度。（就是降低交互的程度）
接口是最低标准。
多重继承
多态：
---------------------------------------------------
定义：某一类事物的多种存 形式
例：动物中的猫、狗
猫这个对象对应的类开型猫类型
猫 X = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物。
动物 y = new 猫();
动物是猫和狗具体事物中抽取出来的
父类型引用指向了子类对象。
这种方式就像从不同角度来描述一个事物，就有不同的解释与说法。只能从当前声明的类型位置去调用父级及当前级别中的方法，而不能调用子类中的方法。
在成员变量与成员函数被重写时，使用父类角度看子类，成员变量看父类自己的，成员函数使用子类的。
（类中，方法可以覆盖，成员变量不能覆盖）
继承和实现是实现多态的前提条件
多态特点：
--------------------------------------------------------------------
成员函数：
编译时：要查看引用变量所属的类中是否有所调用的成员
在运行时：要查看对象所属的类中是否有所调用的成员
成员变量：只看引用变量属的类
匿名内部类
优点：将类的声明、方法的实现、对象的创建一气呵成，节省代码量。
------------------------------------------------
示例：
class NoNameDemo1{
public
static void main(String[] args){
RichMan
rm = new RichMan();
//匿名内部类对象，
rm.findLover(new
Wrb(){
public
void white(){
System.out.println("很白");
}
});
}
}
//白富美
interface Wrb{
public
void white();
}
class RichMan{
public
void findLover(Wrb w){
w.white();
}
}
——————————————————
GUI
————————————————
graphic user interface
适配器模式（通过一个抽象类整合实现的方法）及方法链编程
————————————————————————————
示例及说明：
class AdapterDemo{
public
static void main(String[] args){
//创建一个按钮对象
Button
b1 = new Button();
//调用按钮对象的点击方法；
//通过new
MouseListener(){}创建匿名内部类，作为传入方法的参数，此方法参数为MouseListener接口类型。
b1.setListener(new
MouseListener(){
//对MouseListener接口方法进行空实现。
public
void onClick(){
System.out.println("按钮1——单击");
}
public
void onDbClick(){}
public
void onRightClick(){}
public
void onMiddleClick(){}
});
b1.click();
Button
b2 = new Button();
b2.setListener(new
MouseListener(){
//对MouseListener接口方法进行空实现。
public
void onClick(){
System.out.println("按钮2——单击");
}
public
void onDbClick(){}
public
void onRightClick(){}
public
void onMiddleClick(){}
});
b2.click();
/* 以上b1和b2两个按钮调用的方法是相同的，但却又不得不重实现接口中的方法，这样很繁琐。
------------------------------------------
下面通过适配置模式对以上繁琐的方法进行调整，先让其符合一定条件，减化代码，定义一个MouseAdapter的抽象类，并实现MouseListener接口
*/
Button
b3 = new Button();
//这里使用MouseAdapter适配器抽象类来完成
b3.setListener(new
MouseAdapter(){
//对MouseListener接口中的方法，已由MouseAdapter适配器全部实现，这里只需对需要使用的方法进行重新实现，从而节省了代码量。
public
void onClick(){
System.out.println("按钮3——单击");
}
});
b3.click();
Button
b4 = new Button();
b4.setListener(new
MouseAdapter(){
public
void onClick(){
System.out.println("按钮4——单击");
}
public
void onDbClick(){
System.out.println("按钮4——双击");
}
});
b4.click();
b4.dbClick();
//将b4按钮实现的功能融合到一行代码中，形成一个匿名按钮，执行click()方法
//此方法为方法链编程，就是一直点连接的方法。
new
Button().setListener(new MouseAdapter(){
public
void onClick(){
System.out.println("单击了一个匿名按钮");
}
public
void onDbClick(){
System.out.println("双击了一个匿名按钮");
}
}).click()
.dbClick();
}
}
//定义一个按钮类,用来监听鼠标发生的事件，并根据这些事件做出响应。
class Button{
//定义一个成员变量l,用于保存MouseListener接口类型的变量信息
private
MouseListener l;
//为按钮填加一个监听器，用于监听鼠标事件,这时返回值为void
是空的
//public
void setListener(MouseListener l){
//当创建匿名按钮时，在无返回值的情况下，将无法调用方法，所以将返回值类类型调整为自己
Button类型，并增加 返回语名 return this;
public
Button setListener(MouseListener l){
//在填加监听器时，就对l进行赋值。
this.l
= l ;
//是在使用方法链时使用
return
this ;
}
/*
按钮有单击和双击的操作，也就是按钮的方法,单击或双击的实现其实是调用的监听器的事件方法,那这里的MouseListener其实就是一个接口。
*/
//public
void click(){
//如果链式方法需要连续调用方法时，可以在调用的方法中也设定返回类型，并返回自己
public
Button click(){
//调用传入参数接口的方法
l.onClick();
return
this;
}
//双击方法
public
void dbClick(){
l.onDbClick();
}
}
//定义MouseListener接口
interface MouseListener{
//定义鼠标监听器接口中的方法
public
void onClick();
public
void onDbClick();
public
void onRightClick();
public
void onMiddleClick();
}
//定义MouseAdapter抽象类（适配器模式），实现MouseListener接口，来减化创建按钮对象时方法重用时的繁琐程度。
abstract class
MouseAdapter implements MouseListener{
//使用空实现的方法实现MouseListener接口中所有的方法，在使用时只作重写即可。将不用重新实现接口中的所有方法
public
void onClick(){}
public
void onDbClick(){}
public
void onRightClick(){}
public
void onMiddleClick(){}
}
————————————————————————