目录
多态
多态性的基本概念
对象向上转型（接受或者返回参数的统一性）
对象向下转型
instanceof关键字
Object类
Object类的简介
获取对象信息：toString()
对象比较：equals()
抽象类
抽象类的基本定义
抽象类的相关说明
模板设计模式（抽象类的应用）
包装类
通过原理分析认识包装类
装箱与拆箱
学习笔记
多态
多态是面向对象中的第三大主要特征，多态性是继承性的基础之上扩展出来的概念，也就是父子之间的互相转换处理。
多态性的基本概念
在Java之中，多态性有两种实现模式：
- 方法的多态性
|- 方法的重载 ：同一 个方法名称，可以根据传入参数的类型或个数的不同，实现不同功能的执行。
|- 方法的覆写：同一个方法可能根据使用子类的不同有不同的实现。
- 对象的多态性：指的是父子实例之间的转换处理，它有两种模式
|- 对象的向上转型：父类 父类实例 = 子类实例 ；自动完成转换
|- 对象的向下转型：子类 子类实例 = 子类(父类)实例 ； 强制完成转换
从实际的转型处理来讲，大部分考虑的是对象的向上转型（90%）。对于对象的向下转型，都是往往使用子类的特殊功能（子类可以对父类进行功能扩充），使用向下转型（%3），还有一些时候不会考虑转型（7%）。
对象向上转型（接受或者返回参数的统一性）
对象转型的处理属于多态性，而这一特性必须在继承性的基础上实现。
范例：观察一个简单代码
class Message{
public void print(){
System.out.println("fjhakdslf") ;
}
}
class DataBaseMessage extends Message{
public void print(){
System.out.println("Oracle数据库连接信息...") ;
}
}
public class StringDemo{
public static void main(String[] args){
DataBaseMessage msg = new DataBaseMessage() ;
msg.print() ;
}
}
本程序是一个最简单的方法覆写操作实现，整个程序之中可以发现，由于现在实例化的是子类对象，子类对象覆写了父类中的print方法，所以调用的是子类中的方法。
范例：观察向上转型
class Message{
public void print(){
System.out.println("fjhakdslf") ;
}
}
class DataBaseMessage extends Message{
public void print(){
System.out.println("Oracle数据库连接信息...") ;
}
}
public class StringDemo{
public static void main(String[] args){
Message msg = new DataBaseMessage() ; // 向上转型
msg.print() ;
}
}
那么这个时候就需要思考向上转型这个操作有什么意义？
范例：向上转型的优势，对参数进行统一的设计
class Message{
public void print(){
System.out.println("fjhakdslf") ;
}
}
class DataBaseMessage extends Message{
public void print(){
System.out.println("Oracle数据库连接信息...") ;
}
}
class WebServerMessage extends Message{
public void print(){
System.out.println("Web服务器连接信息...") ;
}
}
public class StringDemo{
public static void main(String[] args){
fun(new DataBaseMessage()) ; //Message msg = new DataBaseMessage()
fun(new WebServerMessage()) ; //Message msg = new WebServerMessage()
}
public static void fun(Message msg){ // 不管传递的是哪个子类，都可以使用一个参数进行接收
msg.print() ;
}
}
向上转型的主要特点是，可以对参数进行统一的设计。但是为什么不适用重载解决当前问题，像下面这样做？
class Message{
public void print(){
System.out.println("fjhakdslf") ;
}
}
class DataBaseMessage extends Message{
public void print(){
System.out.println("Oracle数据库连接信息...") ;
}
}
class WebServerMessage extends Message{
public void print(){
System.out.println("Web服务器连接信息...") ;
}
}
public class StringDemo{
public static void main(String[] args){
fun(new DataBaseMessage()) ; //Message msg = new DataBaseMessage()
fun(new WebServerMessage()) ; //Message msg = new WebServerMessage()
}
public static void fun(DataBaseMessage msg){
msg.print() ;
}
public static void fun(WebServerMessage msg){//重载实现
msg.print() ;
}
}
的确可以实现同样的效果。但是在进行程序类设计的时候，除了满足当前的要求之外，还需要做出可维护性的设计。如果随着项目的发展产生3万个子类，那么每当扩充一个Message子类之后，就需要追加一个fun方法的重载，这样就对程序的维护性造成较大的影响。
强调：向上转型是看实例化的哪一个子类，并且子类有没有进行方法覆写，如果覆写了，调用的方法一定是被覆写过后的子类方法。
对象向下转型
向下转型的主要特特点是使用子类的一些特殊的定义处理。
范例：实现向下转型
class Person{
public void print(){
System.out.println("一个正常的人的行为吃饭、睡觉、繁衍") ;
}
}
class Superman extends Person{
public String fly(){
return "可以飞" ;
}
public String fire(){
return "可以喷火" ;
}
}
public class StringDemo{
public static void main(String[] args){
System.out.println("-----正常状态下的超人是普通人的状态------") ;
Person per = new Superman() ; // 向上转型
per.print() ;
System.out.println("-----外星怪兽够准备骚扰人类------") ;
Superman man = (Superman) per ; // 向下转型
System.out.println(man.fly()) ;
System.out.println(man.fire()) ;
}
} 向上描述的是一些公共的特征，而向下描述的是子类自己特殊的定义环境，但是需要明确的是向下转型并不是一个安全的事情。因为在进行向下转型之前，一定先要向上转型。
范例：观察错误的程序
class Person{
public void print(){
System.out.println("一个正常的人的行为吃饭、睡觉、繁衍") ;
}
}
class Superman extends Person{
public String fly(){
return "可以飞" ;
}
public String fire(){
return "可以喷火" ;
}
}
public class StringDemo{
public static void main(String[] args){
Person per = new Person() ; // 没转型
per.print() ;
System.out.println("-----外星怪兽够准备骚扰人类------") ;
Superman man = (Superman) per ; // 向下转型
System.out.println(man.fly()) ;
System.out.println(man.fire()) ;
}
} 
以后只要是发生对象的向下转型之前，一定要发生向上转型，两个没有发生任何的关系的实例如果要发生强制转换，那么就会发生“ClassCastException”异常，所以向下转型并不是安全的事情。
instanceof关键字
通过分析可以发现向下转型本身是一件危险性的操作，所以为了保证向下转型的正确性，往往需要在进行转型之前进行判断，判断某个实例是否是某个类的对象，这个使用instanceof关键字实现，语法如下：
- 对象 instanceof 类
该判断将返回一个Boolean类型，如果是true表示实例时指定类对象。
范例： 观察instanceof使用
class Person{
public void print(){
System.out.println("一个正常的人的行为吃饭、睡觉、繁衍") ;
}
}
class Superman extends Person{
public String fly(){
return "可以飞" ;
}
public String fire(){
return "可以喷火" ;
}
}
public class StringDemo{
public static void main(String[] args){
Person per = new Person() ; // 没转型
System.out.println(per instanceof Person ) ; // true
System.out.println(per instanceof Superman ) ; //false
}
} 范例： 观察instanceof
class Person{
public void print(){
System.out.println("一个正常的人的行为吃饭、睡觉、繁衍") ;
}
}
class Superman extends Person{
public String fly(){
return "可以飞" ;
}
public String fire(){
return "可以喷火" ;
}
}
public class StringDemo{
public static void main(String[] args){
Person per = new Superman() ; //向上转型
System.out.println(per instanceof Person ) ; // true
System.out.println(per instanceof Superman ) ; //true
}
} 所以在日后的开发之中，如果要进行对象的向下转型，最好先判断一次。如下：
在以后进行一些完善性的程序开发过程之中，一定要进行instanceof判断。
Object类
object类的主要特点是可以解决参数的统一问题，也就是说使用Object类可以接受所有的数据类型。
Object类的简介
在Java之中，只有一个类不存在继承关系的，这个类就是Object，也就是说所有的类默认情况下都是Object的子类。以下两种类的定义效果完全一样。
class Person{ }// 一个类
class Person extends Object {} 在Object类设计的时候考虑到所有继承的问题，所以该类提供有无参构造方法，这样所有类在定义时即便不知道Object类的存在也不会出现构造方法调用失败的问题。
那么Object类是所有类的父类，那么这种情况下就可以使用Object类接收所有的子类对象。
范例：观察Object类接受所有子类对象
class Person{ // 一个类
public void print(){
System.out.println("一个正常的人的行为吃饭、睡觉、繁衍") ;
}
}
public class StringDemo{
public static void main(String[] args){
Object obj = new Person() ; // 向上转型
if (obj instanceof Person){
Person per = (Person) obj ;
System.out.println("Person对象向下转型执行完毕") ;
}
}
} 如果一个程序的方法要求可以接收所有类对象的时候就可以使用object实现处理，但是需要注意，在Java设计的过程之中，对于所有的引用数据类型都可以使用object类进行接收。
范例：使用object类接收数组
public class StringDemo{
public static void main(String[] args){
Object obj = new int [] {1,2,3} ; // 向上转型
if (obj instanceof int []){
int [] data = (int []) obj ; // 向下转型
for (int temp : data){
System.out.println(temp + "、") ;
}
}
}
} object 是一个万能的数据类型，更加适合程序的标准设计。
获取对象信息：toString()
object虽然是一个类，但是这个类的本身也提供一些处理方法的。在object之中提供有toString()的方法，该方法可以获取一个对象的完整信息。
范例：观察默认的toString使用
class Person{ // 一个类
public void print(){
System.out.println("一个正常的人的行为吃饭、睡觉、繁衍") ;
}
}
public class StringDemo{
public static void main(String[] args){
Person per = new Person() ;
System.out.println(per) ;
System.out.println(per.toString()) ;
}
} 可以发现我们之前使用对象调用的时候，使用的方法就是toString()方法，所以这个方法调用与不调用的效果是一样的。所以在以后的开发之中对象信息的获取可以直接覆写此方法。
范例：覆写toString方法
class Person{ // 一个类
private String name ;
private int age ;
public Person(String name, int age){
this.name = name ;
this.age =age ;
}
@Override
public String toString(){
return "姓名：" + this.name + "、年龄：" + this.age ;
}
}
public class StringDemo{
public static void main(String[] args){
Person per = new Person("张三", 20) ;
System.out.println(per) ; // 注意这里时调用的toString
}
} 以后编写简单Java类的过程中，只需要覆写toString方法。
对象比较：equals()
Object类之中另外一个比较重要的方法在于对象比较的处理上，所谓的对象比较是指两个对象的内容是否完全相同。假如现在有两个Person对象，现在需要确认这两个对象是否一致，但是两个对象本身会有不同的内存地址数值，所以此时的比较是通过内容来完成的。
范例：对象比较的基础实现
class Person{ // 一个类
private String name ;
private int age ;
public Person(String name, int age){
this.name = name ;
this.age =age ;
}
@Override
public String toString(){
return "姓名：" + this.name + "、年龄：" + this.age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
}
public class StringDemo{
public static void main(String[] args){
Person perA = new Person("张三", 20) ;
Person perB = new Person("张三", 20) ;
if(perA.getName().equals(perB.getName()) &&
perA.getAge()== perB.getAge() ){ //注意这里使用的是 ==
System.out.println("同一个对象") ;
}else{
System.out.println("不是同一个对象") ;
}
}
} 此时实现了对象的比较功能，但是比较麻烦，因为需要将每一个属性都进行相等的判断。对象比较应该是一个个类内部所具有的功能而不应该在外部定义。
Object类作为所有类的父类提供了对象操作支持，对于对象参所实现可以使用equals()的方法完成。
对象比较：public boolean equals(Object obj)，可以接收所有类型；默认情况下该方法知识进行两个对像的地址判断，并没有进行内容判断。对于实际的使用这而言 ，要进行对象的判断处理，需要进行内容判断，必须在字中覆写次方法，并且进行属性判断。
范例：观察Object类的equals覆写
class Person{ // 一个类
private String name ;
private int age ;
public Person(String name, int age){
this.name = name ;
this.age =age ;
}
@Override
public String toString(){
return "姓名：" + this.name + "、年龄：" + this.age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
// equals()方法这个时候会有两个对象：当前的对象this 、传入对象Object
public boolean equals(Object obj){
if(!(obj instanceof Person)){return false ;}
if(obj == null){return false ;}
if(this == obj){return true ;}
Person per = (Person) obj ; //先进行向下转型，目的为了获取类中的属性
return this.name.equals(per.name) && this.age == per.age ;// 这里再类对象的内部所以可以使用per.name访问private
// 一个使用equals，一个使用==，是string类池的关系
}
}
public class StringDemo{
public static void main(String[] args){
Person perA = new Person("张三", 20) ;
Person perB = new Person("张三", 20) ;
System.out.println(perA.equals("d")) ;
}
} String类作为Object的子类，那么这个类里面已经覆写类equals()方法。
抽象类
类继承主要作用扩充已有类的功能，但是对于之前的操作而言会发现，子类可以有自己的选择任意来覆写某个方法，父类无法对子类做出强制性约定（强制性必须覆写某个方法），这个情况下往往不会采用类的继承，在实际开发之中很少会出现继承一个已经完善的类，可以直接使用的类，而是继承抽象类。在以后类的继承设计时，优先考虑的一定是抽象类。
抽象类的基本定义
抽象类的主要作用在于对子类覆写方法进行约定，在抽象类中可以定义一些抽象方法，以实现这样的约定。抽象方法时使用abstract关键词定义的并且没有提供方法体的方法，而抽象方法所在的类必须是抽象类，抽象类必须使用abstract关键词进行定义（在普通类的基础上追加abstract）。
范例：定义一个抽象类
abstract class Message{ //定义抽象类
private String type ; // 消息的类型
public abstract String getConnectInfo() ; //抽象方法
public void setType(String type){ // 普通方法
this.type = type ;
}
public String getType(){ // 普通方法
return this.type ;
}
} 当一个抽象类定义完后，切记：“抽象类不是完整的”，如果要想去使用抽象类则必须按照如下原则进行：
- 抽象类必须通过使用子类，子类使用extends继承一个抽象类
- 抽象类的子类（不是抽象类），一定要覆写子类中的全部方法。
- 抽象类的对象实例化，可以利用多态性通过子类实例向上转型的方法完成
abstract class Message{ //定义抽象类
private String type ; // 消息的类型
public abstract String getConnectInfo() ; //抽象方法
public void setType(String type){ // 普通方法
this.type = type ;
}
public String getType(){ // 普通方法
return this.type ;
}
}
class DatabaseMessage extends Message{ // 类的继承关系
public String getConnectInfo(){ // 方法覆写
return "Oracle数据库的连接信息" ;
}
}
public class StringDemo{
public static void main(String[] args){
Message msg = new DatabaseMessage() ; // 向上转型
msg.setType("客服消息") ;
System.out.println(msg.getType()) ;
System.out.println(msg.getConnectInfo()) ;
}
} 从整体上上来讲，只是比普通类增加了抽象方法以及对子类的强制性的要求而已，其它过程和传统的类继承完全相同的。
对于抽象类使用的几点意见：
- 抽象类的使用很大程度上有一个核心问题：抽象类无法自己实例化；
- 抽象类之中主要的目的是使用过度操做使用，所以当你要使用抽象类进行开发的时候，往往都是在你设计中需要解决类继承问题时所带来的代码重复处理。
抽象类的相关说明
抽象类是一个重要的面向对象的设计结构，对于抽象类使用的时候需要注意以下几点问题：
- 在定义抽像类的时候不能使用final关键字来进行定义，而抽象类必须有子类，而final定义的类时不能够有子类的。
- 抽象类时作为普通类的加强版出现的（抽象类的组成就是在普通类的基础上扩展而来的，只是追加了抽象方法），那么既然是在普通类的基础上扩展的，就可以在属性类中定义属性与方法，那么这些属性一定要求进行内存空间的开辟。所以抽象类中一定可以提供构造方法，并且子类也会按照子类对象实例化的原则进行父类构造调用。如下：
abstract class Message{ //定义抽象类
private String type ; // 消息的类型
public Message(String type){ // 类中没有提供无参构造
this.type = type ;
}
public abstract String getConnectInfo() ; //抽象方法
public void setType(String type){ // 普通方法
this.type = type ;
}
public String getType(){ // 普通方法
return this.type ;
}
}
class DatabaseMessage extends Message{ // 类的继承关系
public DatabaseMessage(String type){
super(type) ;
}
public String getConnectInfo(){ // 方法覆写
return "Oracle数据库的连接信息" ;
}
}
public class StringDemo{
public static void main(String[] args){
Message msg = new DatabaseMessage("客服消息") ; // 向上转型
System.out.println(msg.getType()) ;
System.out.println(msg.getConnectInfo()) ;
}
} - 抽象类中允许没有抽象方法，但是即便没有抽象方法，也无法使用使用关键字new直接实例化抽象类对象。即便抽象类没有实例化对象，也没法使用关键字new获取抽象类的对象，必须依靠子类完成。
- 抽象类中可以使用static方法，并且该方法不受到抽象类的局限。static方法不受到实例化或结构的限制，永远通过类名称进行调用。如下：
abstract class Message{ //定义抽象类
public abstract String getInfo() ; // 抽象方法
public static Message getInstance(){
return new DatabaseMessage() ; //
}
}
class DatabaseMessage extends Message{ // 类的继承关系
public String getInfo(){
return "数据库连接信息" ;
}
}
public class StringDemo{
public static void main(String[] args){
Message msg = Message.getInstance() ; // 向上转型
System.out.println(msg.getInfo()) ;
}
} 模板设计模式（抽象类的应用）
抽象类的本质上属于一个加强型的类，那么对于这个类已经清楚，可以描述一切有关的显示事物，但是分析也可以发现，抽象类的设计应该比类更高一层的定义。那么现在研究一下抽象类的实际应用。
假如说现在要描述三类事物：
机器人：不需要休息、只知道补充能量和工作；
人：需要休息、需要吃饭和努力工作；
猪：需要休息、需要吃饭和不需要工作；
范例：实现代码
abstract class Action{
public static final int EAT = 1 ;
public static final int SLEEP = 5 ;
public static final int WORK = 10 ;
public void command(int code){
switch (code){
case EAT:{
this.eat() ;
break ;
}
case SLEEP:{
this.sleep() ;
break ;
}
case WORK:{
this.work() ;
break ;
}
case EAT + SLEEP + WORK:{
this.eat() ;
this.sleep() ;
this.work() ;
break ;
}
}
}
public abstract void eat() ;
public abstract void sleep() ;
public abstract void work() ;
}
class Robot extends Action{
public void eat(){
System.out.println("机器人充电") ;
}
public void sleep(){}
public void work(){
System.out.println("机器人按照固定的套路进行工作") ;
}
}
class Person extends Action{
public void eat(){
System.out.println("饿的时候吃饭") ;
}
public void sleep(){
System.out.println("安静的躺下睡觉") ;
}
public void work(){
System.out.println("人类有想法的工作") ;
}
}
class Pig extends Action{
public void eat(){
System.out.println("吃食槽中的饭") ;
}
public void sleep(){
System.out.println("倒地就睡") ;
}
public void work(){}
}
public class StringDemo{
public static void main(String[] args){
Action robotAction = new Robot() ;
Action personAction = new Person() ;
Action pigAction = new Pig() ;
System.out.println("------机器人行为---------") ;
robotAction.command(Action.SLEEP) ;
robotAction.command(Action.EAT) ;
robotAction.command(Action.WORK) ;
System.out.println("------猪行为---------") ;
pigAction.command(Action.SLEEP) ;
pigAction.command(Action.EAT) ;
pigAction.command(Action.WORK) ;
System.out.println("------人行为---------") ;
personAction.command(Action.SLEEP) ;
personAction.command(Action.EAT) ;
personAction.command(Action.WORK) ;
}
} 现在的程序已经完成了一个行为的抽象处理，但是需要思考。现在定义的Action的父类主要目的，对所有行为行为规范进行统一处理。
抽象类的好处：
- 对子类方法的统一管理；
- 可以自身提供一些普通方法，并且这些普通方法可以调用抽象方法（这些抽象方法必须再有子类提供覆写实现才会生效）。
包装类
包装类的主要功能是针对基本数据类型的对象而实现的，并且随着的版本更新，包装类的功能也在发生改变。
通过原理分析认识包装类
Object类最大的特点是所有类的父类，并且可以接收所有的数据类型，但有一个问题：基本数据类型是不是一个类，那么将基本数据类型进行类的处理，那么就需要对其进行包装。
范例：以int 数据为例实现包装处理
class Int{
private int data ; //包装了一个基本数据类型
public Int(int data){
this.data = data ;
}
public int intValue(){
return this.data ;
}
}
public class StringDemo{
public static void main(String[] args){
Object obj = new Int(10) ; //装箱：将基本数据类型保存在包装类之中
int x = ( (Int)obj ).intValue() ; //拆箱：从包装类对象中获取基本数据类型
System.out.println(x*2) ;
}
} 将基本数据类型进行包装处理过后，可以实现像对象一样引用传递，也可以使用Object进行接收，但是如果都已经发现基本数据类型与Object之间的缺陷，那么JDK早就发现了这样问题，所以JDK1.5就提供了包装类的概念，基本数据类型一共有八种，所以提供了八种包装类，那么这八种包装类的基本定义如下：
现在发现在Java包中一共提供两种类型：
- 对象型包装类（object 直接子类）：Boolean、Character
- 数值型包装类（Number直接子类）：byte、short、 intenger、long、float、double
Number是一个抽象类，以后看到Number都要明确它是一个数字的概念，这个类的定义如下：
- public byte byteValue() 普通 从包装类中获取byte定义
- public short shortValue() 普通 从包装类中获取short定义
- public abstract int intValue() 普通 .....
- public abstract long longValue() 普通 ....
- public abstract float floatValue() 普通 ...
- public abstract double doubleValue() 普通 ........
Numbet类中的方法就是提供有对象获取包装类型中基本数据类型的功能。一共只定义了六个方法
装箱与拆箱
基本数据类型的包装都是为了基本数据类型转为对象提供的，这样就对基本类型和包装之间就有了如下的操作关系：
- 数据装箱：将基本数据类型保存到包装类之中，一般可以利用构造方法完成
|- Integer类： public Integer(int value) ;
|- double类： public Double(double value);
|- boolean类：public Boolean(boolean value);
- 数据拆箱：从包装类中获取基本数据类型：
|- 数值型包装类已经有Number类定义有拆箱的方法；
|- boolean型：public boolean booleanValue();
范例：以int和Integer为例
public class StringDemo{
public static void main(String[] args){
Integer obj = new Integer(10) ; // 装箱
int num = obj.intValue() ;// 拆箱
System.out.println(num * num);
}
} 范例：以double与Double为例
public class StringDemo{
public static void main(String[] args){
Double obj = new Double(10.1) ; // 装箱
double num = obj.doubleValue() ;// 拆箱
System.out.println(num * num);
}
} 可以发现从jdk1.9之后，对于所有包装类中提供的构造方法就变为过期处理，这是因为从jdk1.5之后为了方便处理提供了自动的装箱与拆箱操作，手工的模式基本没有用了。
范例：观察自动的拆箱与装箱
public class StringDemo{
public static void main(String[] args){
Integer obj = 10 ; // 自动装箱
int num = obj ; // 自动拆箱
obj ++ ; //包装类对象可以直接参与运算
System.out.println(num * obj);
}
} 除了提供这种自动的数学运算支持之外，使用自动装箱的好处是可以实现Object接收基本数据类型的操作。
范例：object接收小数
public class StringDemo{
public static void main(String[] args){
Object obj = 19.2 ; // double自动包装为Double,向上转型为Object
double num = (Double) obj ;//向下转型为包装类，自动拆箱
System.out.println(num * num) ;
}
} JDK1.5之后提供的自动支持功能，到了JDK1.9之后为了巩固此概念，所以将包装类的构造方法设置为过期定义。
但是对于包装类需要注意关于相等判断上，如下：
范例：观察相等判断
public class StringDemo{
public static void main(String[] args){
Integer x = 99 ;
Integer y = 99 ;
System.out.println(x == y) ; // true
}
} public class StringDemo{
public static void main(String[] args){
Integer x = 128;
Integer y = 128 ;
System.out.println(x.equals(y) ) ;
}
} 以后进行包装类相等判断时，一定要使用equals完成，而包装类本身也需要考虑占位的长度，如果超出一位的内容就需要使用equals比较，如果不超过使用“==”就可判断。