轻烟薄雾}
6.接口interface
* 接口（interface） 是与类并行的一个概念
* 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。 * 2.接口是没有构造器的。
* 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。 * 比如：class CC extends DD implements AA
* 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
* 5.类可以实现多个接口。----java 中的类的继承是单继承的 * 6.接口与接口之间也是继承的关系，而且可以实现多继承 * >5,6描述的是java中的继承的特点。 * 7.接口与具体的实现类之间也存在多态性
* 8.面向接口编程的思想： 工厂方法的设计模式
//接口的应用：工厂方法的设计模式 public class TestFactoryMethod { public static void main(String[] args) { IWorkFactory i = new StudentWorkFactory(); i.getWork().doWork(); IWorkFactory i1 = new TeacherWorkFactory(); i1.getWork().doWork(); } }
interface IWorkFactory{ Work getWork(); }
class StudentWorkFactory implements IWorkFactory{ @Override public Work getWork() { return new StudentWork(); } }
class TeacherWorkFactory implements IWorkFactory{ @Override public Work getWork() { return new TeacherWork(); } }
interface Work{ void doWork();
}
class StudentWork implements Work{ @Override public void doWork() { System.out.println(\学生写作业\ } }
class TeacherWork implements Work{ @Override public void doWork() { }
}
System.out.println(\老师批改作业\
代理模式
//接口的应用：代理模式（静态代理） public class TestProxy { public static void main(String[] args) { Object obj = new ProxyObject(); obj.action(); } }
interface Object{ void action(); }
//代理类
class ProxyObject implements Object{ Object obj; public ProxyObject(){
System.out.println(\代理类创建成功\ obj = new ObjctImpl(); } public void action(){ System.out.println(\代理类开始执行\ obj.action(); System.out.println(\代理类执行结束\ } }
//被代理类
class ObjctImpl implements Object{ @Override
}
public void action() { System.out.println(\被代理类开始执行======\ System.out.println(\具体的操作======\ System.out.println(\被代理类执行完毕======\ }
7.内部类
* 类的第5个成员：内部类
* 1.相当于说，我们可以在类的内部再定义类。外面的类：外部类。里面定义的类：内部类
* 2.内部类的分类：成员内部类（声明在类内部且方法外的） vs 局部内部类(声明在类的方法里) * 3.成员内部类： * 3.1是外部类的一个成员：①可以有修饰符（4个）②static final ③可以调用外部类的属性、方法 *
* *
3.2具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器
* 4.局部内部类： *
* 5.关于内部类，大家掌握三点：
* ①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象） * ②如何区分调用外部类、内部类的变量(尤其是变量重名时) * ③局部内部类的使用 （见TestInnerClass1.java） 总结
面向对象的三条主线： 1.类及类的成分
2.面向对象的三大特性
3.其他的关键字：this super import package abstract static final interface等
1.java程序是关注于类的设计。类从代码的角度：并列关系！ 从执行、设计的角度：关联关系、继承关系、聚合关系
class A{ }
class B{
A a = new A(); }
2.类的成分：属性 方法 构造器 代码块 内部类 2.1 属性：①变量的分类：成员变量（属性 Field） vs 局部变量(方法的形参、方法内部、代码块内部)
基本数据类型（8种，不同的数据类型对应不同的默认初始化值） vs 引用数据类型（数组、类、接口 默认初始化值为null）
②属性的声明格式：修饰符 数据类型 变量名 = 初始化值；//java是强数据类型的语言
③对属性的赋值的操作：1.默认初始化 2.显式的初始化 3.代码块的初始化 4.构造器的初始化；5.调用方法、属性进行赋值
2.2 方法 ①格式：修饰符 （其它的关键字：static/final/abstract）返回值类型 方法名（形参列表）{ //方法体 }
②方法的重载(overload) vs 方法的重写(override overwrite) ③ 方法的参数传递机制：值传递（难点）
2.3构造器 ①构造器的作用：1.创建类的对象 2.初始化对象的成员变量 ②构造器也是可以重载的。 2.4 代码块 主要作用：用来初始化类的成员变量
分类：静态的代码块 vs 非静态的代码块
2.5 内部类 ①分类：成员内部类（static的成员 vs 非static的成员） vs 局部内部类（方法内部声明的类）
②掌握 :①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象） ②如何区分调用外部类、内部类的变量(尤其是变量重名时) ③局部内部类的使用 （见TestInnerClass1.java） 3. 类的初始化（创建类的对象）
3.1 如何创建类的对象。如： Person p = new Person(); Date d = new Date(); 3.2 内存解析：
①栈：局部变量、对象的引用名、数组的引用名 堆：new 出来的“东西” 方法区：（字符串常量池） 静态域：存放类中静态的变量
②如何理解创建的对象在内存中加载的过程（理解） 3.3 子类对象实例化的全过程： SubClass sc = new SubClass(); 4.面向对象的三大特性： 4.1 封装性： ① 通过私有化类的成员变量，通过公共的getter和setter方法来调用和修改 ② 还可以对类的其他结构进行“封装”
③ 权限修饰符：public protected 缺省 private 4.2 继承性： 通过让一个类A继承另一个类B，就可以获取类B中的结构（主要的：属性、方法、构造器）。子类：类A 父类：类B
>java中的类的继承性：单继承的。 4.3 多态性：
①体现：方法的重载与重写 ； 子类对象的多态性 Person p = new Student(); ②子类对象多态性的使用：虚拟方法调用。
③向上转型 向下转型 Student s = (Student)p; //建议在向下转型之前： if ( p instanceof Student)避免出现ClassCastException的异常
5.其它关键字：
5.1 this:修饰属性、方法、构造器 。表示：当前对象或当前正在创建的对象
5.2 super：修饰属性、方法、构造器。显式的调用父类的相应的结构，尤其是子父类有重名的方法、属性
5.3 static : 修饰属性、方法、代码块、内部类。随着类的加载而加载！ 5.4 final：修饰类、属性、方法。表示“最终的” 5.5 abstract : 修饰类、方法
5.6 interface：表示是一个接口，（接口是与类并列的一个结构）。类与接口之间同时“implements”发生关系。
5.7 package import 。。。
>abstract不能修饰属性、构造器、不能与final static private共用。
6.Bank项目
六、异常处理 1.体系结构
java.lang.Object
|----java.lang.Throwable |-------java.lang.Error：错误，java程序对此无能为力，不显式的处理 |-------java.lang.Exception:异常。需要进行处理 |------RuntimeException:运行时异常 |-----ArrayIndexOutOfBoundsException/NullPointerException/ArithmeticException/ClassCastException
|------非RuntimeException:编译时异常
2.因为java程序分为javac.exe和java.exe两个过程，在每个过程中，都有可能出现异常。故分为编译时异常、运行时异常
2.1 对于运行时异常比较常见，可以不显式的来处理。 2.2 对于编译时异常，必须要显式的处理 编译时异常，不是说有异常才处理，而是存在异常的隐患，必须在编译前，提示程序，万一出现异常，如何处理！
2.如何处理异常？
java 中的“抓抛模型”
* 1.\抛\：当我们执行代码时，一旦出现异常，就会在异常的代码处生成一个对应的异常类型的对象，并 * 将此对象抛出。(自动抛出 / 手动抛出)
* >一旦抛出此异常类的对象，那么程序就终止执行 * >此异常类的对象抛给方法的调用者。
* 2.\抓\：抓住上一步抛出来的异常类的对象。如何抓？即为异常处理的方式 * java 提供了两种方式用来处理一个异常类的对象。 * 处理的方式一： * try{
* //可能出现异常的代码 * }catch(Exception1 e1){ * //处理的方式1 * }catch(Exception2 e2){
* //处理的方式2 * }finally{
* //一定要执行的代码 * }
* 注：1.try内声明的变量，类似于局部变量，出了try{}语句，就不能被调用 * 2.finally是可选的。
* 3.catch语句内部是对异常对象的处理： * >getMessage(); printStackTrace();
* 4.可以有多个catch语句，try中抛出的异常类对象从上往下去匹配catch中的异常类的类型，一旦满足 * 就执行catch中的代码。执行完，就跳出其后的多条catch语句 * 5.如果异常处理了，那么其后的代码继续执行。
* 6.若catch中多个异常类型是\并列\关系，孰上孰下都可以。
* 若catch中多个异常类型是\包含\关系，须将子类放在父类的上面，进行处理。否则报错！ * 7.finally中存放的是一定会被执行的代码，不管try中、catch中是否仍有异常未被处理，以及是否有return
