1.封装
（1）作用:属性封装(private)，即包装，不给外部看见。
（2）被封装的属性必须用setter 和getter方法来设置和取得内容。
（3）可以用setter设置属性,限制。(比如setAge，年龄限制在多少)
2.继承
（1）作用:解决代码重复(重用)的问题。
（2）格式:class 子类 extends 父类{}
扩充一个类已有的功能，比如子类扩充了父类所没有的属性 和方法，实际上将父类定义的更加具体化，比如:树和百年老树，父类表示的范围大，子类表示的范围小。
（3）限制:①Java不允许多重继承，但允许多层继承。(单继承局限)
即，一个子类只能有一个父类，一个父类可以有多个子类，子类的子类叫孙子类。
class A{}
class B extends A{}
class C extends B{} （多层继承，最多不要超过三层）
②子类只能继承父类的公有属性，private属性不能继承，只能利用setter或getter方法进行间接访问。
③实例化子类对象时会默认先执行父类构造(默认使用无参构造)，调用父类构造的方法体先执行，再实例化子类对象并且调用子类的构造方法。（对于子类构造来说，相当于隐含super()）
class A{
public A(){
System.out.println("A类构造方法！"); }}
class B extends A{
public B(){
System.out.println("B类构造方法！"); }} //这里隐含了super()方法;
public class Test(){
public static void main(String args[]){
new B();
}}
//执行结果 A类构造方法！ B类构造方法！
特别说明：当父类提供有无参构造方法时，是否编写super()方法没有区别。但是如果父类中没有
无参构造方法时，则必须明确使用super()方法来调用父类指定参数的构造方法。
(4) 在继承中super与this的用法与区别。
this用于调用属性 调用方法 调用构造方法。
| super使用注意事项: | this使用注意事项: |
|①super必须出现在子类的方法或构造方法中。 --|-①通过this调用构造方法，仅仅在类的构造方法中才能使用。-|
|②用于访问父类成员,例如父类的属性 方法 构造方法。 | ②函数参数或函数中的局部变量和成员变量同名时, 则需要用"this.成员变量"来引用成员。 |
|③访问权限有限制,无法通过super访问private成员| | ③引用该函数当前对象时，直接用this。|
super()与this()的不同
super: this:
1.功能 子类调用父类构造 父类方法 父类属性。 调用本类构造 本类方法 本类属性。
2.形式 不查找子类,直接调用父类操作。 先查找本类中是否存在有指定的调用结构，如果有则直接调用，没有则调用父类定义。
3.特殊 ———— 表示本类的当前对象。
简单来说，就是super()认准父类，只查找父类。this()认准本类，优先查找本类，没有再调用父类。
3.覆写(分为方法的覆写和属性的覆盖，下面只说方法的覆写)
(1)作用:继承性的主要特征是子类可以根据情况对父类进行扩充,当子类发现父类方法名称功能不足时可以考虑覆写。
(2)格式:子类定义方法时,定义的方法名与父类的方法名同名。
B和A必须具有相同的方法名，相同的参数列表，返回值类型相同。
一个类可能会产生多个子类,每个子类都可能会覆写父类中的方法,这样一个方法就会根据不同的子类有不同的实现效果。
(3)顺序:观察实例化的时那个类,观察这个实例化的类里面调用的方法是否已经被覆写过,如果没被覆写过则调用父类。
(4)限制:被子类覆写过的方法不能拥有比父类更严格的访问控制权限。
方法的重载和覆写的区别
发生范围: 重载发生在一个类里面，覆写发生在继承关系里面。
定义:重载方法名称相同，参数的类型及个数不同。 覆写方法名称，参数的类型和个数相同，方法返回值相同。
权限:重载方法没有权限的限制。 覆写 被覆写的方法不能拥有比父类更为严格的访问控制权限。
4.final关键字
(1)final:在Java中final被称为终结器，在Java里面可以使用final定义类，方法和属性。
(2)作用: (类中)使用final定义的类不能再有子类，即：任何类都不能继承以final声明的父类。
(方法中) 使用final定义的方法不能被子类所覆写。
(属性)使用final定义的变量就成为了常量，常量必须在定义的时候设置好内容，并且不能修改。(常量名称使用全部大写的形式)
(3)全局变量: public + static + final 联合定义的常量。 如:public static final String MSG=“HELLO”; (公共常量)
5.多态性
(1)多态性:1.方法的多态性与2.对象的多态性。
1.重载:同一个方法名称相同，根据不同的参数类型及个数完成不同的功能。
覆写:同一个方法名称相同, 根据实例化的子类对象不同,所完成的功能也不同。
2.对象的多态性:父子类对象的转换。(看new的是谁(
向上转型: 子类对象变为父类对象，格式 ： 父类 父类对象 = 子类实例 ， 自动转换; A a= new B();
向下转型: 父类对象变为子类对象, 格式 : 子类 子类对象 = (子类) 父类实例 ， 强制转换; B b = (B) a; （父类调用子类方法)
向下转型前必须发生向上转向才可以向下转型。（int和long)
(2)多态：同一个引用类型，使用不同的实例而执行不同操作。(同一种事物，由于条件不同，产生的结果也不同)
(3)多态产生的条件:继承、方法重写、父类的声明和子类的实例化。
(4)作用:对象向上转型的主要意义在于参数的统一，向下转型指的是父类调用子类的个性化操作方法。
instanceof关键字(判断某个对象是否是指定类的实例)
对象 instanceof 类 返回 boolean型 （判断向下转型)
6.抽象类
(1)抽象类:指在普通类的结构里面增加抽象方法的组成部分，抽象方法指的是没有方法体的方法，同时抽象方法还必须使用abstract关键字进行定义。拥有抽象方法的类一定属于抽象类，抽象类要使用abstract声明。
(2)作用:利用抽象类可以明确定义子类需要覆写的方法。
(3)普通方法与抽象方法的区别: 普通方法有 "{}"来表示方法体， 有方法体的方法一定可以被对象直接调用。
抽象方法没有方法体,声明时不需要加 “{}”,但是必须有abstract声明。 public abstract void A();
(4)使用原则:抽象类不能直接实例化对象。
原因:因为抽象方法没有方法体，而没有方法体的方法如何调用,不能调用如何产生实例化对象。
①抽象类必须有子类，即每一个抽象类一定要被子类所继承(使用extends)关键字,
因为Java的单继承局限,所以一个子类只能够继承一个抽象类。
②抽象类的子类(子类不是抽象类)必须覆写抽象类中的全部抽象方法（强制子类覆写 );
③依靠对象的向上转型概念,可以通过抽象类的子类完成抽象类的实例化对象操作。
(5)限制:①抽象类不能使用final定义，因为抽象类必须有子类，而final定义的类不能有子类。
②抽象类中可以没有任何抽象方法，但只要是抽象类，就不能直接使用关键字new实例化对象。
③抽象类中依然可以定义内部的抽象类，而实现的子类也可以根据需要选择是否定义内部类来继承抽象内部类。（P233 范例4-40）
④外部抽象类不允许使用static声明，而内部的抽象类允许使用static声明，此时内部抽象类就相当于是一个外部抽象类，
继承的时候使用 “外部内.内部类”的形式表示类名称。（static 定义的是类）
⑤在抽象类中，如果定义了static属性或方法，就可以在没有对象的时候直接调用。（此时可以没有子类）
7.接口
(1)接口:接口是一种约定(标准)和能力。interface声明接口，implements实现接口。
接口与接口之间只能继承 不能实现。接口作为标准用于解耦合以及不同层之间的连接桥梁。
(2)定义:接口作为一个特殊的类，这个类里面只有抽象方法与全局变量。
interface A{
( public static final )String MSG= “HELLO”;
public (abstract) void fun();
}
(3)使用:①接口必须要有子类，但是此时一个子类可以使用implements关键字实现多个接口，避免单继承局限。
（子类可以实现多个接口，但是子类只能够继承一个抽象类）多个接口: class X implements A,b
②接口的子类(如果不是抽象类)，必须要覆写接口中的全部抽象方法。
③接口的对象可以利用子类对象的向上转型进行实例化操作。
④如果一个子类既要继承抽象类又要实现接口，那么应该采用先继承（extends）后实现接口（implements）的顺序完成。
class X extends C implements A,B
⑤一个抽象类可以继承一个抽象类或者实现若干个接口，但是反过来，一个接口却不能继承抽象类。一个接口可以使用extends关键字
同时继承多个父接口。（接口多继承）
(4)抽象类与接口的区别（优先考虑接口）
抽象类 接口
①关键字： abstract class interface
②组成： 构造 普通 抽象 static 方法 常量 变量 抽象方法 全局变量
③子类使用： class 子类 extends 抽象类 class 子类 implements 接口，接口，……
④关系：一个抽象类只能继承一个抽象的父类，抽象类可以实现多个接口。而接口不能继承抽象类，但一个接口可以继承（用extends）多个父接口。
⑤权限: 可以使用各种权限 只能使用public权限
⑥限制： 单继承局限 没有单继承局限
⑦子类： 抽象类和接口都必须有子类，子类必须要覆写全部的抽象方法。
⑧实例化对象： 都是依靠子类的向上转型进行对象的实例化。
一个子类只能继承一个抽象类，却可以实现多接口。（接口主要用于解决单继承局限）
抽象类要被子类继承，接口要被类实现。
(5)接口的应用1.——工厂设计模式（解决代码耦合带来的问题）
代码编写标准:①客户端（即主方法）调用简单，不需要关注具体细节；
②程序代码的修改，不影响客户端的调用，即使用者可以不去关心代码的变更。
解决new所带的的代码耦合度问题。
interface Person{
public void act();}
class Eat implements Person{
public void act(){
System.out.println("吃饭");}}
class Drink implements Person{
public void act(){
System.out.println("喝水");}}
class Factory { //工厂类
public static Person getInstance(String className){
if("eat".equals(className)){
return new Eat();
}else if("drink".equals(className)){
return new Drink();
}else {
return null;}}}
public class Test{
public static void main(String args[]){
Person p = Factory.getInstance("eat");
p.act();}}
本程序在客户端的操作上取消了new的使用,而使用 Facatory.getInstance()方法根据指定子类标记取得接口实例化，
这时客户端不再需要关注具体子类，也不需要关注Factory类是怎样处理的只需要关注如何取得接口对象并操作。
2.——代理设计模式
代理设计是指一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。
代理设计模式的格式：①接口②真实主题 ③ 代理主题 ④主类(客户端)
interface Network{ //接口
public void browse();
}
class Real implements Network{ //真实主题
public void browse(){
System.out.println("上网浏览");
}
}
class Proxy implements Network{ //代理主题
private Network network;
public Proxy(Network network){ //设置代理的真实操作
this.network=network; //设置代理的子类
}
public void check(){ //与具体上网相关的操作
System.out.println("检查用户是否合法");
}
public void browse(){
this.check(); //可以同时调用多个与具体业务相关的操作
this.network.browse(); //调用真实上网操作
}
}
public class Test2{
public static void main(String args[]){
Network net =new Proxy(new Real()); //定义接口对象实例化对象，同时传入代理的真实操作
net.browse(); //客户只关心上网一个功能
}
}
在本程序中，真实主题实现类完成的只是上网的最基本功能，而代理主题要做比真实主题更多的相关业务操作。
区分 对象 类 抽象类 接口 继承 实现（P253）
回答：接口是在类之上的标准。
8.static用法
static可以用来修饰属性、方法和代码块
static修饰的属性和方法称为类属性（类变量）、类方法
不使用static修饰的属性和方法，属於单个对象，通常称为实例属性（实例变量）、实例方法
static修饰的变量和方法可以通过类名和对象名访问，而不用static修饰的变量和方法只能通过对象名访问
接口中定义的属性都是默认static final的常量
9.修饰符
1） private
类中限定为private的成员，只能被这个类本身访问。
如果一个类的构造方法声明为private，则其它类不能生成该类的一个实例。
2） friendly
类中不加任何访问权限限定的成员属于缺省的（friendly）访问状态，可以被这个类本身和同一个包中的类所访问。
3） protected
类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
可以修饰属性和方法
本类、同包、子类可以访问
4） public
类中限定为public的成员，可以被所有的类访问。
访问修饰符总结 本类 同包 子类 其他
private √
默认(friendly) √ √
protected √ √ √
public √ √ √ √
10.包——解决类的同名问题
包的作用：1.文档分门别类，易于查找。2.易于管理。3.不同内容的文档可以放在不同的袋子中，拥有相同的名字，避免冲突
创建包：使用package声明包，以分号结尾
包命名规范：包名由小写字母组成，不能以圆点开头或结尾
分别创建包和类：
创建项目→创建包→创建类
创建类的过程中创建类所在的包
创建项目→创建包和类
导入包：为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类
