Java基础一：面向对象的特征

　　经过16年校招，自己在Java基础方面也算有了一个质的飞跃，从原来知其然，到现在知其所以然，现将学习心得总结于此。

　　首先需要知道类和对象是什么？

　　维基百科定义类为： an extensible program-code-template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods)，即能够为创建对象实例提供可扩展的模板，提供数据和行为操作。在实现角度，其以字节码的形式存储在内存中的方法区，用来实例化对象。

　　维基百科定义对象为：a location in memory having a value and possibly referenced by an identifier，即在内存上一段包含数据并由某标识符引用的区域。在实现角度，类对象实体存储在堆内存中，其地址存储在栈上的对象引用中（即类的对象变量，其指向对象所在的内存空间）。

 

　　面向对象的特征有哪些方面？（参照Java面试题全集） 

• 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 

• 继承：继承是从已有类得到继承信息创建新类的过程，提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。 

• 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。 

• 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2). 对象造型（用父类型对象引用子类对象，这样同样的对象调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

　　（1）重载与重写

　　重载：

• • 方法重载是让类以统一的方式处理不同类型数据的一种手段，函数同名，但参数个数和类型不同；
  • 调用方法的时候，通过传递不同的参数决定使用哪个方法，实现多态；
  • 重载时，函数同名，参数不同，返回值类型可相同也可以不同。
    

　　重写：

• • 父类与子类之间的多态，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，则该方法被重写或覆盖。
  • 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法，可采用super关键字调用父类方法；
  • 子类函数的访问修饰权限不能少于父类的。

　　注意1：无法以返回值类型区分重载函数。

　　从封装的角度理解：一个方法包括返回值类型、方法名、参数列表和方法体。方法体被方法封装，方法名和参数是这个封装体对外提供的接口。

　　至于返回值是与方法体有关，它是方法体执行的结果，它的有无是由方法体决定的。也就是说先有方法体，才有返回值，它不是封装体对外提供的接口，当我们调用方法时就是调用的这个对外的接口（方法名和参数列表），所以不能把返回值作为方法的重载。

　　但也有特例，在编译器可以根据语境判断出语义时，如int x=f()；也可以区分重载函数。直接 f();是无法区分重载函数的。

　　注意2：Java中接口（interface）的存在也体现了运行时多态。

　　总结：

　　多态可从接口实现、重载和重写三方面解释：

• • 接口与实现的分离，一个接口可以对应不同的实现，实现多态；
  • 重载，一种类中多态性的表现，多种同名、参数不同的方法实现多态，属于编译时多态性；
  • 重写，继承产生的多态，子类对父类的方法进行重新定义，从而不同的子类对象对同一消息做出不同的响应，属于运行时多态性。

　　（2）对象造型（casting），造型转换或者类型转换

• 向上转型（upcasting），Java中子类对象可以直接赋给父类对象，这个时候父类对象引用的就是子类对象的内存空间。即子类-->父类，父类可以根据子类对象的内存空间，执行不同的行为。父类对象和子类对象引用同一个对象，但编译器将父类对象仍看作父类型。

                注意：父类对象引用（引用子类）不可以访问子类对象新增加的成员（属性和方法）；

                    　　可以使用 引用变量 instanceof 类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

• 向下转型（downcasting），Java中将父类对象赋给子类对象时，要进行造型转换（即强制类型转换）。即父类-->子类，程序可以通过编译，但需要运行时进行检查，此时根据父类是否引用子类对象的内存空间，会出现不同的结果。

                如果父类变量引用的是正确的子类类型（即父类对象引用的是子类型的内存空间，然后赋给子类对象），则赋值将执行；如果父类变量引用的不是相关的子类型，将产生ClassCastException异常。例如：A是B的父类，A a=new B(); B b=(B) a; 执行时不会报异常。 如果A a=new A(); B b=(B) a; 执行时就会报异常。

                补充：向下转型严格按照上边的标准，数组符合条件也可以进行强制转换。

　　　

转型举例说明：

        Object[] o={"qw","we","rt"};  //o为Object类型的对象数组  getClass()返回class [Ljava.lang.Object;
        Object[] oo=new String[]{"qw","we","rt"};//oo为Object类型数组，但其引用子类String的数组  getClass()返回class [Ljava.lang.String;
        Object ooo="qw"; //ooo为Object变量 ，默认为String类型    getClass()返回class java.lang.String;

        //String[] s=(String[]) o;  //运行时会报异常：java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
        String[]ss=(String[]) oo; //运行正常
        String sss=(String) ooo; //运行正常，可将Object转换为String

        System.out.println(oo);
        System.out.println(ss);
        System.out.println(ooo);
        System.out.println(sss);
        System.out.println(ooo.getClass());    

输出结果：

[Ljava.lang.String;@28d93b30
[Ljava.lang.String;@28d93b30
qw
qw
class java.lang.String

 再举一例：

public class TestCasting{
    public static void main(String args[]){
        Animal a = new Animal("a");
        Cat c = new Cat("c","catColor");
        Dog d = new Dog("d","dogColor");

        System.out.println(a instanceof Animal);    //true
        System.out.println(c instanceof Animal);    //true
        System.out.println(d instanceof Animal);    //true
        System.out.println(a instanceof Dog);        //false

        a = new Dog("d2","dog2Color");        //父类引用指向子类对象，向上转型
        System.out.println(a.name);                //可以访问
        //System.out.println(a.folorColor);   //!error   不可以访问超出Animal自身的任何属性
        System.out.println(a instanceof Animal);    //是一只动物
        System.out.println(a instanceof Dog);        //是一只狗，但是不能访问狗里面的属性

        Dog d2 = (Dog)a;    //强制转换
        System.out.println(d2.folorColor);    //将a强制转换之后，就可以访问狗里面的属性了

        Dog[] dogs = new Dog[2];
        dogs[0] = new Dog("dog1","black");
        dogs[1] = new Dog("dog2","yellow");
        Animal[] animals = dogs;
        Dog[] dogs1 = (Dog[]) animals;
        System.out.println(dogs);
        System.out.println(dogs1);
    }
}
class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
}
class Dog extends Animal{
    public String folorColor;
    public Dog(String name,String folorColor){
        super(name);
        this.folorColor = folorColor;
    }
}
class Cat extends Animal{
    public String eyesColor;
    public Cat(String name,String eyesColor){
        super(name);
        this.eyesColor = eyesColor;
    }
}

输出结果：

true
true
true
false
d2
true
true
dog2Color
[LDog;@28d93b30
[LDog;@28d93b30

　　总结：

• • 向上转型，即将子类对象赋给父类对象，父类对象指向子类对象内存空间，可以访问父类中定义的属性和方法，无法调用子类新添加的属性和方法；
  • 向下转型，即将父类对象赋给子类对象，此时根据父类对象引用的空间绝对运行时是否会发生异常；
  • 数组也遵守以上规则。

全文总结：

• 理解类与对象的基本概念；
• 面向对象的基本特征：抽象、继承、封装和多态；
• 多态包括编译时多态和运行时多态，另有接口与实现的分离；
• 重载与重写的区别；
• 类型转换：向上转型与向下转型