单列模式

public class TeacherController {

private TeacherController(){};

private static TeacherController t = new TeacherController();

private static TeacherController getInstance(){
    return t;
}

public static void main(String[] args) {
    getInstance();
}

}

必会知识点:
1：继承(extends)
(1)继承的体系结构(理解)：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。
**先学习顶层内容，因为它是共性内容。
**一般使用的时候使用的是底层的类。
(2)继承的好处:(理解)
A：继承的出现，提高了代码的复用性。
B：继承的出现，让类与类之间产生了关系，extends来表示，
这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。
(3)特点(理解)
A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。
B：java支持多重(层)继承。
(4)注意：(掌握)
A：子类可以直接访问父类中的非私有的属性和行为。
B：不要仅为了获取其他类中部分功能而去继承。
C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
**如何判断A和B是否有继承关系？
**A如果继承B，那么就可以说A是B的一种。

2：抽象类(abstract)
(1)只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。（掌握）
(2)抽象类的特点（掌握）(演讲内容)
A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方 法。
B：抽象类是不能够被实例化的。不能够创建对象的。
C：如果一个类继承抽象类，那么，它要么实现抽象类中的所有抽象方法，
要么本身也是抽象类。
(3)抽象类的成员特点：（掌握）
A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和 以前是一样的)
B：成员方法：抽象类中分为两种方法，一种是抽象方法，这种方法在子类中必须要被 实现。

	C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就			有构造方法。
		它的构造方法有用吗？有，为了让子类实例化的时候使用。

(4)举例：教师举例，学生举例，员工举例
(5)抽象类的相关问题：	
	A：抽象类中是否有构造函数？参照(3)里面的C。
	B：抽象关键字abstract不可以和哪些关键字共存？
		**private
			***私有的，外部直接无法访问。
		**static
			***那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。
		**final
			***final修饰的方法不能被重写。所以它和abstract冲突。
	C：抽象类中可不可以没有抽象方法？
		**可以。防止其他类创建该类对象。

知识点总结：
1：接口(interface)(掌握)
(1)接口的由来：当一个类中的方法都是抽象的时候，你没必要定义为抽象类，
定义为接口就可以了。
(2)解决了java中只能单继承的问题。(对多继承进行了优化)
A：类与类：只能是单继承。
B：接口与接口：可以是单继承，也可以是多继承。
C：类与接口：可以是单实现，也可以是多实现。
(3)成员特点：
A：只有成员变量和成员方法。
B：成员变量 默认修饰符 public static final
**int x = 20;
**其实是这样的 public static final int x = 20;
C：成员方法 默认修饰符 public abstract
**void show();
**其实是这样的 public abstract void show();
建议：自己手动加上修饰符。

(4)接口特点：
A：接口是对外暴露的规则
B：接口是功能的扩展
C：接口降低了程序的耦合性。
**内聚(自己实现功能的能力)
**高内聚，低耦合。
举例：主板和CPU,USB接口,电源插座。
D：扩展说了下接口的理解
**狭义的理解就是java中的接口。
**广义的理解就是：任何定义的规范都是接口。

(5)接口和抽象类的区别：
A：抽象类只能被单继承；接口可以被多实现。
B：抽象类中的成员：
成员变量:可以是常量，也可以是变量。
成员方法:可以是抽象的，也可以是非抽象的。
构造方法:虽然不可以创建对象，但是可以给子类实例化用。
接口中的成员：
成员变量：只能是常量。默认修饰符 public static final
成员方法：只能是抽象的。默认修饰符 public abstract
C：抽象类中定义的是体系结构中的共性的内容。
接口中定义的是对象的扩展功能。
D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。
接口被实现表示的是: "like a"的关系。xx像yy中的一种。

(6)学生：Student
A：属性：学号,姓名,年龄
B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)

	发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。
	      但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。
	      这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，
	      我们定义一个接口来放抽烟这个功能。
         interface Smoking
	 {
		public abstract void smoking();
	 }
   描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

SmokeStudent ss = new SmokeStudent();
ss.eat();
ss.study();
ss.smoking();

  老师：Teacher
	A：属性 教师编号,姓名,年龄
	B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)

	发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。
	      但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。
	      这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，
	      我们定义一个接口来放抽烟这个功能。
         interface Smoking
	 {
		public abstract void smoking();
	 }
  描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking
	SmokeTeacher st = new SmokeTeacher();
	st.eat();
	st.teach();
	st.smoking();
  最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。
  所以，我们进一步向上抽取。来了一个Person类
  Person：属性：姓名，年龄
          行为：吃饭(抽象eat)

3：Object(掌握)
(1)Object类：java中所有类的父类。它是java类体系结构中的根类。
java中的类都直接或者间接继承自Object类。
(2)学习了里面的几个方法:重点掌握 toString(),equals()。
A：boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。
B：String toString()
返回该对象的字符串表示。
C：int hashCode()
返回该对象的哈希码值。
D：Class<?> getClass()
返回此 Object 的运行时类。
E：protected void finalize() 了解
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
**final,finally,finalize
4：关键字用来修饰什么？(掌握)
类 属性 方法 构造方法
private OK OK OK
默认 OK Ok Ok OK
protected Ok Ok OK
public Ok Ok Ok OK
static Ok Ok
final Ok Ok Ok
abstract Ok Ok

5：jar(掌握)
(1)打包：
jar -cf haha.jar packa
(2)查看jar包
jar -xvf haha.jar
(3)如果内容特别多，好几个屏幕都放不下，
假使我们能够通过某个命令，讲这些目录写入到一个记事本中。看起来就方便了。
jar -tf haha.jar > c:\a.txt