封装

定义： 隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。
目的： 增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。
基本要求: 把所有的属性私有化，对每个属性提供 getter 和 setter 方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写 toString 方法，但这不是必须的。
封装的步骤：
1. 修改属性的可见性（设为 private ，防止错误的修改）
2. 创建公有的 getter / setter 方法（用于属性的读写）
3. 在 getter / setter 方法中加入属性控制语句（对属性的合法性进行判断）
类成员的访问修饰符：

作用域 / 修饰符	Public	Protected	无修饰符（default）	Private
同一个类	√	√	√	√
同一个包	√	√	√	×
（不同包的）子类	√	√	×	×
不同包	√	×	×	×

实例：

/*封装类*/
public class Encapsulation_Demo {
private String name;
private int age;

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
}

/*实现类*/
public class Encapsulation_Demo_Test {
public static void main(String[] args) {
    Encapsulation_Demo ed = new Encapsulation_Demo();
    ed.setName("Fatli");
    ed.setAge(20);
    System.out.println("Name:"+ed.getName()+" "+"Age:"+ed.getAge());
}
}

封装类 < POJO ≈ entity实体类 < JavaBean

封装类：将类的变量声明为 private ，提供公共 setter 和 getter 方法以修改和查看变量值。
POJO ： Plain Old Java Object 的缩写，可以理解为简单的 JavaBean 。 POJO 实质上可以理解为简单的实体类，顾名思义 POJO 类的作用是方便程序员使用数据库中的数据表，对于广大的程序员，可以很方便的将 POJO 类当做对象来进行使用，当然也是可以方便的调用其 getter , setter 方法。
entity 实体类：就是属性类，通常定义在 model 层里面。一般的实体类对应一个数据表，其中的属性对应数据表中的字段。实体类就是一个拥有 getter 和 setter 方法的类。 entity （实体类）的作用一般是和数据表做映射。实体类通常总是和数据库之类的（所谓持久层数据）联系在一起。介于 dao 和 service 之间。
JavaBean 是遵循 Sun 定义的 JavaBeans 约定的类。
JavaBeans是 Java 中一种特殊的类，可以将多个对象封装到一个对象（bean）中。特点是可序列化，提供无参构造器，提供 getter 方法和 setter 方法访问对象的属性。名称中的 “Bean” 是用于 Java 的可重用软件组件的惯用叫法。https://zh.wikipedia.org/wiki/JavaBeans 如果一个Java类的每个实例变量都被 private 修饰，并为每个实例变量提供了 public 修饰的 setter 和 getter 方法，那么这个类是符合 JavaBean 规范的类。因此， JavaBean 总是一个封装良好的类。
JavaBeans 是可重用的 Java 软件组件，可以在构建器工具中可视化操作。实际上，它们是用符合特定约定的 Java 编程语言编写的类。它们用于将许多对象封装到单个对象（bean）中，以便它们可以作为单个 bean 对象而不是多个单独对象传递。 JavaBean 是可序列化的 Java 对象，具有 nullary 构造函数，并允许使用 getter 和 setter 方法访问属性。为了充当 JavaBean 类，对象类必须遵守关于方法命名，构造和行为的某些约定。这些约定使得可以使用可以使用，重用，替换和连接 JavaBean 的工具。所需的约定是：
- 该类必须有一个公共默认构造函数。这允许在编辑和激活框架内轻松实例化。
- 类属性必须可以使用 get ， set 和其他方法（所谓的访问器方法和 mutator 方法），遵循标准命名约定。这允许在框架内轻松自动检查和更新 bean 状态，其中许多包括各种类型的属性的自定义编辑器。
- 类应该是 serializable 可序列化的。这允许应用程序和框架以独立于 VM 和平台的方式可靠地保存，存储和恢复 bean 的状态。
- 因为这些需求大部分表示为约定而不是通过实现接口，一些开发人员将 JavaBean 视为遵循特定命名约定的普通 Java 对象。

继承

目的： 实现代码复用(重用)。
介绍： 当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。继承后子类自动拥有了父类的属性和方法。
注意： 父类的私有属性和构造方法并不能被继承。另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法即方法的重写。子类不能继承父类中访问权限为 private 的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到 protected 。
使用继承的方法：
- 编写父类
- 编写子类，继承父类（ Java 中只支持单根继承，即一个类只能有一个直接父类）

[访问修饰符] class Pet {
    //公共的属性和方法
}

[访问修饰符] class Dog extends Pet {
    //子类特有的属性和方法
}

子类访问父类成员：
- 访问父类构造方法
  - super();
  - super(name);
- 访问父类属性
  - super.name
- 访问父类方法
  - super.print();
super 关键字用以访问父类成员：
- 使用 super 关键字， super 代表父类对象
- super 只能出现在子类的方法和构造方法中
- 调用构造方法是，必须是第一句
- super 不能访问父类的 private 成员
继承条件下构造方法的调用规则：
- 子类构造方法没有通过 super 显式调用父类的有参构造方法，也没有通过 this 显式调用自身的其他构造方法：
  - 系统默认调用父类的无参构造方法
- 子类构造方法通过 super 显式调用父类的有参构造方法：
  - 执行父类相应的构造方法。而不执行父类的无参构造方法
- 子类构造方法通过 this 显式调用自身的其他构造方法，在相应的构造方法中应用以上的两条规则
继承和权限：

方法重写

方法的重写或方法的覆盖（overriding）：
- 子类根据需求对从父类继承的方法进行重新编写（例如鸵鸟继承鸟类的飞翔方法，但鸟类的飞翔方式并不适用鸵鸟，所以鸵鸟需要重写鸟类的飞翔方法）
- 重写后，子类对象无法访问父类中被覆盖的方法，可以用 super.方法 （或者 父类名.方法 ）的方式来调用父类中被覆盖的方法
- 构造方法不能被重写
  - 子类中重写父类 private 方法并不是真正的重写，只是定义了一个新方法
方法重写的规则：
- 方法名相同
- 参数列表相同
- 返回值类型相同或者是其子类
- 访问权限不能严于父类
- 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
- 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法
- 父类的私有方法不能被子类覆盖
- 不能抛出比父类方法更多的异常
方法重写 override 与方法重载 overload 区别：
- 重载主要发生在同一个类的多个同名方法之间；重写发生在子类和父类的同名方法之间
- 重载是在一个类中定义多个形参列表不同的同名方法（只能重载构造方法）；重写是在子类中定义与父类形参列表相同的同名方法。两者只是都需要方法名相同，并无太大的相似之处

比较项	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

附：方法重载的作用（只能重载构造方法）提高了程序的可读性。使得程式设计人员能较少苦恼于方法名称的设计。如果我们只需要执行一个操作，同名的方法将增加程序的可读性。在编程过程中，是要遵守编程规范的，这就要求方法的命名是要有意义的，而有的方法可能面临着：会有不用的参数列表。这时会用到重载，这样，既可以表示方法的意义，又表示这些方法是相关方法，方便调用。所以，方法重载，很大程度是为了程序的可读性，即使不用，也是不会妨碍程序运行的。

Object 类

Object类是所有类的父类

public class  Pet  extends Object {
…… 
}

Object 类被子类经常重写的方法

方法	说明
toString()	返回当前对象本身的有关信息，按字符串对象返回
equals()	比较两个对象是否是同一个对象，是则返回 true
hashCode()	返回该对象的哈希代码值
getClass()	获取当前对象所属的类信息，返回 Class 对象

Object 类的 equals() 方法与操作符 ==
- equals() 比较两个对象是否是同一个对象，是则返回 true
- 操作符 ==
  - 简单数据类型，直接比较值。如 1 == 2
  - 引用类型，比较两者是否为同一对象

Object 类的 equals() 方法与==没区别当有特殊需求，如认为属性相同即为同一对象时，需要重写 equals() Java.lang.String 重写了 equals() 方法，把 equals() 方法的判断变为了判断其值

多态

概念： 相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。
实现多态的三个必要条件： 继承、重写、向上转型。只有满足这三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
- 继承：在多态中必须存在有继承关系的子类和父类。
- 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
- 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
多态的实现方式：
- 基于继承实现的多态：基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。
- 基于接口实现的多态继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
多态性的主要表现
- 方法重载：通常指在同一个类中,相同的方法名对应着不同的方法实现,但是方法的参数不同.
- 成员覆盖：通常指在不同类(父类和子类)中,允许有相同的变量名,但是数据类型不同;也允许有相同的方法名，但是对应的方法实现不同.
多态的好处：程序的可扩展性及可维护性增强。

实例：

//为宠物看病
public void cure(Pet pet) {
if (pet.getHealth() < 50)   //健康值小于50得治
pet.toHospital();
}

//测试方法
Pet pet = new Dog();
pet.setHealth(20);
Master master = new Master();   //主人类省略了
master.cure(pet);

使用父类作为方法的形参，是Java中实现和使用多态的主要方式使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式

类型转换

向上转型

向上转型：父类的引用指向子类对象( Pet pet = new Dog() )。自动进行类型转换

//测试方法
Pet pet = new Dog();
pet.setHealth(20); 
Master master = new Master(); 
master.cure(pet);

<父类型> <引用变量名> = new <子类型>();
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法(需要向下转型)

向下转型

向下转型：将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换。

Dog dog=(Dog)pet;   //将 pet 转换为 Dog 类型
dog.catchingFlyDisc();  //执行 Dog 特有的方法

<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

instanceof

如何减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常？这是需要用到 instanceof 运算符进行类型的判断。
Java 中提供了 instanceof 运算符来进行类型的判断。instanceof 可以用于判断一个引用类型所引用的对象是否一个类的实例。
注意：使用 instanceof 时，对象的类型必须和 instanceof 后面的参数所指定的类在继承上有上下级关系。

抽象类

抽象类与抽象方法实例（2个）：

public abstract class Pet { //抽象类
public abstract void toHospital();  抽象方法 
}

public abstract class AbstractClass{    //里面至少有一个抽象方法
public int t;                      //普通数据成员
public abstract void method1();  //抽象方法，抽象类的子类在类中必须实现抽象类中的抽象方法
public abstract void method2(); 
public void method3();            //非抽象方法
public int method4();
public void method3(){
    ……                            //抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现
　　}
　　publi int method4 (){
    ……                            //抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现
　　}
}

抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。通常在编程语句中用 abstract 修饰的类是抽象类。含有抽象方法的类称为抽象类，它不能生成对象。抽象类是不完整的，它只能用作基类（用于被继承）。在面向对象方法中，抽象类主要用来进行类型隐藏和充当全局变量的角色。参考： http://www.runoob.com/java/java-abstraction.html

抽象类 & 普通类：
- 抽象类不能被实例化（不能生成对象）
  - 但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例（多态）
- 普通类可以被实例化
抽象方法：以 abstract 修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。当一个方法为抽象方法时，意味着这个方法应该被子类的方法所重写（重载主要发生在同一个类的多个同名方法之间；重写发生在子类和父类的同名方法之间）。抽象方法的修饰符只能用 public 或者 protected 修饰或者不用修饰符，不能被 static ， private 修饰。原因如下：抽象方法没有方法体，是用来被继承的，所以不能用 private 修饰； static 修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义。
- 抽象方法 & 普通方法 & 构造方法
  - 抽象方法无方法体。实例： public abstract void method1();
  - 普通方法有方法体。实例： public void method2(){ …… }
  - 构造方法是一个与类同名且没有返回值类型（连 void 也不能有）的方法。用以初始化对象。构造方法分为两种：无参构造方法、有参构造方法。 Java 类隐式声明一个无参构造方法。 Person p = new Person() 中的 Person() 和 public Base(){System.out.println("父类的无参构造方法");}
- 抽象方法 & 抽象类：
  - 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
  - 如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
  - 没有抽象构造方法，也没有抽象静态方法
  - 抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
实例：

public abstract class Base {
    //抽象类中可以没有抽象方法,但包含了抽象方法（没有方法体）的类就必须被定义为抽象类
    public abstract void method1();
    public abstract void method2();
    public void method3(){}
    //没有抽象的构造方法。
    //public abstract Base(){}
    //没有抽象的静态方法。
    //static abstract void method4();
    public Base(){
        System.out.println("父类的无参构造方法");
    }
    static void method4(){
        System.out.print("静态方法表示类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。因此，当前类必须为静态方法提供实现");
    }
}

//如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
public abstract class Sub1 extends Base {
    public void method1() {
        System.out.println("重写父类的method1");
    }
}

//否则就必须实现父类的所有抽象方法
public class Sub2 extends Base {
    public Sub2(){
        System.out.println("子类的无参构造方法");
    }
    @Override
    public void method1() {
        System.out.println("重写父类的抽象方法method1");
    }
    @Override
    public void method2() {
        System.out.println("重写父类的抽象方法method2");
    }
}

public class Test {
    public static void main(String[] args) {
        //抽象类不允许实例化
        //Base base=new Base();
        //抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
        //抽象类不能被实例化（不能生成对象）,但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例（多态）
        Base sub=new Sub2();//输出：父类的无参构造方法 <br /> 子类的无参构造方法
        sub.method1();    //输出：重写父类的抽象方法method1
        sub.method4();    //输出：静态方法表示类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。因此，当前类必须为静态方法提供实现
    }
}

抽象类与接口的区别:

在 interface 中所有的方法都被隐式声明为 public abstract 的（接口是一种特殊的抽象类，所有方法都是（隐式声明）抽象方法，接口可以让所有的类去实现 implements （而抽象类的被继承 extends ））；所有的数据成员都被隐式声明为 public static final 的，即使你没有声明。实现 interface 的类，其 interface 中所有的方法必须被“实现”，否则这个类成为一个抽象类。
不同点：
- Interface 可以从多个 interface 得到继承，但是不能继承类。一个类可以实现多个 interface （抽象类只能单继承，接口可以多继承）
- 抽象类可以有非抽象的方法和构造方法、变量，但是接口只能有抽象方法，静态常量。（接口不允许被实例化，所以接口中没有构造方法）
- 抽象类和子类具有父子关系，子类能拥有父类中一些属性。接口虽然某个类实现一个接口，但是由于接口中的变量都为静态常量，不存在继承关系。
相同点：
- 无论接口还是抽象类，都无法直接实例化，其自身实例化需要靠实现类或子类来实现。
- 接口和抽象类都必须被实现其中的所有方法。

接口 interface

接口（英文：Interface），在 Java 编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。参考： http://www.runoob.com/java/java-interfaces.html

接口的几个基本特性：
- 接口没有构造方法，不能被实例化（常作为类型使用）
- 实现类必须实现接口的所有方法
- 实现类可以实现多个接口（ Java 中的多继承）
  - implements 多个接口，使用逗号隔开
- 接口中的所有方法都是抽象方法（public abstract）
- 接口中的变量都是静态常量（public static final）

实例：

public interface UsbInterface {
void service(); //USB 接口提供服务。隐式声明为 public abstract 抽象方法。
}

public class UDisk implements UsbInterface {
@Override
public void service() {
    System.out.println("U盘连接 USB 口，开始传输数据。");
}
}

public class UsbFan implements UsbInterface {
    @Override
    public void service() {
        System.out.println("USB风扇连接 USB 口，开始转动。");
    }
}

public class UsbTest {
    public static void main(String[] args) {
        //U盘
        UsbInterface UDisk = new UDisk();
        UDisk.service();
        //风扇
        UsbInterface UsbFan = new UsbFan();
        UsbFan.service();
    }
}

Qingquan-Li / blog

Java 面向对象三大特性以及抽象类和接口 #34

封装

封装类 < POJO ≈ entity实体类 < JavaBean

继承

方法重写

Object 类

多态

类型转换

向上转型

向下转型

instanceof

抽象类

抽象类与接口的区别:

接口 interface