一、OOP特征一：封装(Encapsulation)
为什么要封装?
在研究封装性之前，我们先来看一段代码：
class Book {
String title;
double price;
public void getInfo() {
System.out.println("图书的名称：" + title + " 图书的价格：" + price);
}
}
public class BookTest {
public static void main(String args[]) {
Book book = new Book();
book.title = "Java开发";
book.price = -89.9;
book.getInfo();
}
}运行结果：
图书的名称：Java开发 图书的价格：-89.9
以上代码没有任何语法错误，却存在一个业务逻辑的错误，因为图书的价格不能为负数。
使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。
造成这种情况的的原因在于：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。
但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)，此时，针对于属性就体现了封装性。
我们需要将Book类中的属性设置为对外不可见（只能是本类访问），可以使用private关键字来定义属性。
封装的体现
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性；
1、修改属性的可见性 —> 设为private
2、创建共有(public)的 getter / setter方法 —> 用于属性的读写
3、在getter / setter方法中加入属性控制语句 —> 对属性值的合法性进行判断
属性私有化
class Book {
String title;
private double price;
public void getInfo() {
System.out.println("图书的名称：" + title + " 图书的价格：" + price);
}
}
public class BookTest {
public static void main(String args[]) {
Book book = new Book();
book.title = "Java开发";
book.price = -89.9;
book.getInfo();
}
}提示:
错误提示：
The field Book.price is not visible
运行报错:
java: price 在 Book 中是 private 访问控制
注意：不同工具的提示各不相同。但是大致意思相似，都是表明该字段是不可见的，也就是隐藏起来了。
我们发现，在访问属性的时候，外部的对象无法再直接调用类中的属性了，此时就相当于Book类的属性对外部不可见。
但是，要想让程序可以正常运行，那么必须让外部可以操作Book类的属性。在Java开发中，针对属性有这样的定义，在类中定义的属性都要求使用private声明，如果属性需要被外部所使用，那么按照要求，定义属性相应的setter和getter方法。
提供操作属性的方法
以Book类中的String price 为例：
（1）setter方法是设置属性内容：
public void setPrice(double price)
主要：有参数。
（2）getter方法是取得属性内容:
public double getPrice()
注意：无参数。
示例：为封装属性设置操作方法。
class Book {
String title;
private double price;
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public void getInfo() {
System.out.println("图书的名称：" + title + " 图书的价格：" + price);
}
}
public class TestDemo {
public static void main(String args[]) {
Book book = new Book();
book.title = "Java开发";
book.setPrice(-89.9);
book.getInfo();
}
}运行结果：
图书的名称：Java开发 图书的价格：-89.9
发现，图书的价格是负数，需要加入检查业务逻辑错误的代码，可以在setter中增加验证，如果值为正，赋值，否则为默认值0.0：
public void setPrice(double price) {
if (price < 0) {
System.out.println("Wrong number of price!");
return;
}
this.price = price;
}对于数据验证，在Java标准开发中应该由辅助代码完成。在实际开发中，setter往往只是简单的设置属性内容，getter只是简单的取得属性内容。
开发建议：以后在定义类的时候，所有的属性都要编写private封装，封装之后的属性如果需要被外部操作，则编写setter、getter。
上述操作其实就是封装的部分体现。
封装的体现：
1、属性的封装。
2、不对外暴露的私有的方法。
3、构造函数的封装。（单例模式）
等
举例结合异常：
public class Human {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) throws Exception {
// 封装age的检验逻辑，而不是暴露给每个调用者去处理
if (age > 120 || age < 0) {
throw new Exception("Invalid value of age");
}
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}封装的好处
1、只能通过规定方法访问数据
2、隐藏类数据的实现细节
3、方便修改实现
4、方便加入控制语句
5、可以修改属性的读(getter)写(setter)权限
如果只提供getter,那么表示只读;
如果只提供setter,那么表示只写;(一般很少)
封装总结
封装(encapsulation)又叫隐藏实现(Hiding the implementation)，就是只公开代码单元的对外接口，而隐藏其具体实现。
比如手机，手机的键盘，屏幕，听筒等，就是其对外接口。你只需要知道如何按键就可以使用手机，而不需要了解手机内部的电路是如何工作的。再比如我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？封装机制就像手机和洗衣机一样只将对外接口暴露，而不需要用户去了解其内部实现。
封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样降低了对内部数据的影响，提高了程序的安全性和可维护性。
封装就是隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
jdk常用类里面有很多方法，有一部分是隐藏起来的，不让外部程序直接使用，只能在类的方法里面调用，该暴露的暴露出来。
二、OOP特征二：继承(Inheritance)
为什么要使用继承?
为描述和处理学生信息，定义类Student:
public class Student {
public String name;
public int age;
public Date birthDate;
public String school;
public String getInfo() {
return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
}
public void sleep() {
System.out.println("睡觉行为");
}
public void study() {
System.out.println("学习行为");
}
}为描述和处理员工信息，定义类Employee:
public class Employee {
public String name;
public int age;
public Date birthDate;
public String company;
public String getInfo() {
return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
}
public void sleep() {
System.out.println("睡觉行为");
}
public void work() {
System.out.println("工作行为");
}
}为描述和处理厨师信息，定义类Chef:
public class Chef {
public String name;
public int age;
public Date birthDate;
public String grade;
public String getInfo() {
return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
}
public void sleep() {
System.out.println("睡觉行为");
}
public void cooking() {
System.out.println("做饭行为");
}
}以上三个类，我们会发现有相同的行为和特征，都有name、age、birthDate属性 和 gettInfo、sleep方法，那么类似的抽象实体有很多，比如：Teacher类、Customer类、Waiter类等；如果我们都按照现在的写法去做，那么相当于N个类里面都要定义相同的属性和行为，这个代码的重用率太低;
针对于这个问题，我们应该要想办法提高代码的重用性。
具体怎么做呢？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”。
继承性的好处/作用:
继承就是为了提高代码的复用性，减少代码的冗余；
便于功能的扩展；
为多态性的使用，提供了前提。
注意：不要仅为了获取其他类中某个功能而去继承。
继承是什么?
按照现有类的类型来创建新类，无需改变现有类的形式，采用现有类的形式并在其中添加新代码，这种方法就叫做继承。继承会使子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法。也就是说，子类和父类是“相似的”。
下面举一个继承的例子：
上图所示，动物继承生物类；老虎又继承动物类。从这个例子中可以明显看出：越往上的类是越抽象，越往下的类越具体。而在我们在设计的时候，父类也往往是比较抽象的类。
继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类‘所有’的特征和行为，使得子类对象（实例）具有父类的成员变量和方法，或类从父类继承方法，使得子类具有父类相同的行为。
继承是所有OOP语言和Java语言不可缺少的组成部分。当创建一个类时，总是在继承，因此，除非已明确指出要从其他类中继承，否则就是在隐式地从Java的标准根类Object进行继承
继承的体现
关键字 extends 表明正在构造的新类派生于一个已存在的类。
已存在的类被称为超类（super class）、基类（base class）或父类（parent class）；
新类被称为子类（subclass）、派生类（derived class）或孩子类（child class）。
类继承语法规则:
class Subclass extends SuperClass{ }
继承的体现：
1、一旦子类继承父类以后，子类中就获取了父类中声明的所有的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
2、子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展，我们称之为子类的扩展。
在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
子类和父类的关系，不同于子集和集合的关系。
编写父类：提取共有的属性和方法
public class Person {
public String name;
public int age;
public Date birthDate;
public String getInfo() {
return "名字: " + name + ",年龄: " + age + ",出生日期: " + birthDate;
}
public void sleep() {
System.out.println("睡觉行为");
}
}编写子类：继承父类
使用extends关键字，让子类继承父类，那么子类就拥有了父类定义的属性和方法，无需重复定义；
子类示例代码：
public class Student extends Person{
public String school;
public void study() {
System.out.println("学习行为");
}
}
public class Employee extends Person{
public String company;
public void work() {
System.out.println("工作行为");
}
}
public class Chef extends Person{
public String grade;
public void cooking() {
System.out.println("做饭行为");
}
}测试类示例代码：
public class ExtendsTest {
public static void main(String[] args) {
Student student = new Student();
// Student类里面没有定义这三个属性，但是因为继承了Person类，就拥有了Person类定义的属性
student.name = "张三";
student.age = 22;
student.birthDate = new Date(1992, 12, 22);
// school属性是Student类里面定义的，我们可以称之为子类的扩展
student.school = "北京大学";
// Student类里面没有定义这两个，但是因为继承了Person类，就拥有了Person类定义的方法
student.getInfo();
student.sleep();
// study()是Student类里面定义的，我们也可以称之为子类的扩展
student.study();
// 其他类似
}
}理解私有继承
某些书本表明“子类只能继承父类的非私有属性和方法”，然而事实并非如此，实际上“Java中子类可以继承父类所有的属性和方法”，只不过因为私有的原因，子类不能调用父类的私有方法。
//父类
public class Father {
private String name = "张三";//私有属性
private String sex = "男";
public void tell() {
System.out.println("姓名：" + name);
System.out.println("性别：" + sex);
}
private void speak() {
System.out.println(name + "is speaking!");
}
private void sleep(){
System.out.println("sleep...");
}
public void eat(){
System.out.println("eat...");
sleep();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
//子类
public class Child extends Father {
}
//测试类
public class TestJava {
public static void main(String[] args) {
Child c = new Child();
c.tell();// tell方法是可以用的
// c.speak();//报错，父类的私有方法不可见
c.eat();
}
}可以看到测试类中即使没有给Child类对象的属性进行赋值，tell方法依旧是可用的。如果Child类中没有继承父类的私有属性，那么tell方法应该会报错。由此得出的结论是，子类会继承父类的所有东西，而修饰符只是影响属性或者方法对外是否可见。
Java官方文档的解释：子类不能继承父类的私有属性，但是如果子类中公有的方法影响到了父类私有属性，那么私有属性是能够被子类使用的。
理解：子类不能直接访问父类中私有的(private)的成员变量和方法。
继承的规则
Java只支持单继承和多层继承，不允许多重继承。
1、一个类可以被多个子类继承。
2、Java中类的单继承性：一个类只能有一个父类（直接父类）。
3、子父类是相对的概念。
4、子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。
5、子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。
继承总结
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，还可以以此基础添加新方法和成员变量来满足需求。
继承需要符合的关系是：is-a，父类更通用，子类更具体。
Java只支持单继承和多层继承，不允许多重继承。
继承就是为了提高代码的复用性，减少代码的冗余，更加便于功能的扩展，并且为多态性的使用，提供了前提。
代码重用是一点，最重要的还是所谓向上转型，即父类的引用变量可以指向子类对象，这是Java面向对象最重要特性多态的基础。
不能被继承的父类成员：构造方法，构造函数不能被继承，但是子类可以通过super()显示调用父类的构造函数
继承的优缺点
在面向对象语言中，继承是必不可少的、非常优秀的语言机制，它有如下优点：
代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性;
提高代码的重用性；
子类可以形似父类，但又异于父类；（拥有了父类的共性,还可以拥有自己的特性）;
提高代码的可扩展性，实现父类的方法就可以“为所欲为”了。（方法的重写）
提高产品或项目的开放性。
自然界的所有事物都是优点和缺点并存的，继承的缺点如下：
继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法；
降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束；
增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果——大段的代码需要重构。
三、OOP特征三：多态(Polymorphism)
何为多态
从字面意思理解：可以理解为一个事物的多种形态。怎么叫一个事物的多种形态呢？
看代码分析：
public class Person {
String name;
int age;
int id = 1111;
public void eat(){
System.out.println("人：吃饭");
}
public void walk(){
System.out.println("人：走路");
}
}
public class Man extends Person{
boolean isSmoking;
int id = 2222;
public void earnMoney(){
System.out.println("男人负责挣钱养家");
}
public void eat(){
System.out.println("男人多吃肉，长肌肉");
}
public void walk(){
System.out.println("男人霸气的走路");
}
}
public class Woman extends Person{
boolean isBeauty;
public void goShopping(){
System.out.println("女人喜欢购物");
}
public void eat(){
System.out.println("女人少吃，为了减肥");
}
public void walk(){
System.out.println("女人窈窕的走路");
}
}
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();
System.out.println("---------------------------");
// 对象的多态性：父类的引用指向子类的对象
Person p2 = new Man();
Person p3 = new Woman();
}
}
一个人类，既可以是一个男人对象，也可以是一个女人对象；这就是对象的多态性。
多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象;
注：可以直接应用在抽象类和接口上。
多态的使用
封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。
继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。同时继承也为实现多态做了铺垫。
那么什么是多态呢？多态的实现机制又是什么？
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
多态情况下，“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。
示例代码：
Student m = new Student();
m.school = “pku”; // 合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; // 非法,Person类没有school成员变量
属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
多态的前提：
① 类的继承关系 ② 方法的重写
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）public class PersonTest {
public static void main(String[] args) {
// 对象的多态性：父类的引用指向子类的对象
Person p = new Man();
// 多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
p.eat();
p.walk();
// 编译报错
// p2.earnMoney();
System.out.println(p.id);// 1111
}
} 对象的多态 —在Java中,子类的对象可以替代父类的对象使用。
一个变量只能有一种确定的数据类型。
一个引用类型变量可能指向(引用)多种不同类型的对象。
示例代码：
Person p = new Student();
Object o = new Person();// Object类型的变量o，指向Person类型的对象
o = new Student(); // Object类型的变量o，指向Student类型的对象
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
所以对于多态我们可以总结如下：
指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。
对于面向对象而已，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编译之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。
多态是编译时行为还是运行时行为？
//证明如下：
class Animal {
protected void eat() {
System.out.println("animal eat food");
}
}
class Cat extends Animal {
protected void eat() {
System.out.println("cat eat fish");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("Dog eat bone");
}
}
class Sheep extends Animal {
public void eat() {
System.out.println("Sheep eat grass");
}
}
public class InterviewTest {
public static Animal getInstance(int key) {
switch (key) {
case 0:
return new Cat ();
case 1:
return new Dog ();
default:
return new Sheep ();
}
}
public static void main(String[] args) {
int key = new Random().nextInt(3);
System.out.println(key);
Animal animal = getInstance(key);
animal.eat();
}
}理解虚拟方法调用：
正常的方法调用：
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();
虚拟方法调用(多态情况下):
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法
编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定
多态的意义
定义：子类对象赋值给父类类型的变量，通俗地说就是是将子类对象转为父类对象。
class Person{
public void print() {
System.out.println("人类");
}
}
class Student extends Person{
public void print() {
System.out.println("我是学生");
}
}
class Teacher extends Person{
public void print() {
System.out.println("我是老师");
}
}
public class Test{
public static void main(String[] args) {
Person per=new Student();// 对象的多态
per.print();
}
}
向上转型需要注意的地方
1. 向上转型后，子类单独定义的方法会丢失（父类并不知道子类定义的新属性与方法）
2. 父类引用可以指向子类对象，但是子类引用不能指向父类对象（除非强转）
3. 如果子类中重写了父类的方法，那么调用这个方法的时候，将会调用子类中的方法
那么重点来了，向上转型的意义究竟是什么？
减少重复代码
实例化的时候可以根据不同的需求实例化不同的的对象，实现参数统一化
//多态性的使用举例一：
public class AnimalTest {
public static void main(String[] args) {
AnimalTest test = new AnimalTest();
test.func(new Dog());
test.func(new Cat());
}
public void func(Animal animal){//Animal animal = new Dog();
animal.eat();
animal.shout();
if(animal instanceof Dog){
Dog d = (Dog)animal;
d.watchDoor();
}
}
// public void func(Dog dog){
// dog.eat();
// dog.shout();
// }
// public void func(Cat cat){
// cat.eat();
// cat.shout();
// }
}
class Animal{
public void eat(){
System.out.println("动物：进食");
}
public void shout(){
System.out.println("动物：叫");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
public void shout(){
System.out.println("汪！汪！汪！");
}
public void watchDoor(){
System.out.println("看门");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void shout(){
System.out.println("喵！喵！喵！");
}
}
//举例二：
class Order{
public void method(Object obj){
}
}
//举例三：
class Driver{
public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
//规范的步骤去操作数据
// conn.method1();
// conn.method2();
// conn.method3();
}
}简而言之，多态其实是在继承的基础上的。比如说今天我们要去动物园参观动物，那么你说我们去参观兔子、参观绵羊、参观狮子、参观豹子都是对的，但你不能说我们去参观汽车。在这个例子中，子类具有多态性：除了使用自己的身份，还能充当父类。
方法重写和重载对比
1. 二者的定义细节：略
2. 从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
instanceof 操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
public class Test {
public void method(Person e) {
if (e instanceof Person){
// 处理Person类及其子类对象
}
if (e instanceof Student){
//处理Student类及其子类对象
}
if (e instanceof Graduate){
//处理Graduate类及其子类对象
}
}
}对象类型转换
基本数据类型的Casting：
自动类型转换：容量小的数据类型可以自动转换成容量大的数据类型；
如long g=20; double d=12.0f
强制类型转换：可以把容量大的数据类型强制转换(casting)成容量小的数据类型；
如 float f=(float)12.0; int a=(int)1200L
对Java对象的强制类型转换称为造型：
从子类到父类的类型转换可以自动进行；
从父类到子类的类型转换必须通过造型(强制类型转换)实现；
无继承关系的引用类型间的转换是非法的；
在造型前可以使用instanceof操作符测试一个对象的类型；
示例代码：
public class ConversionTest {
public static void main(String[] args) {
double d = 13.4;
long l = (long) d;
System.out.println(l);
int in = 5;
// boolean b = (boolean)in;
Object obj = "Hello";
String objStr = (String) obj;
System.out.println(objStr);
Object objPri = new Integer(5);
// 所以下面代码运行时引发ClassCastException异常
String str = (String) objPri;
}
}public class Test {
public void method(Person e) { // 设Person类中没有getschool() 方法
// System.out.pritnln(e.getschool()); //非法,编译时错误
if (e instanceof Student) {
Student me = (Student) e; // 将e强制转换为Student类型
System.out.pritnln(me.getschool());
}
}
public static void main(String[] args){
Test t = new Test();
Student m = new Student();
t.method(m);
}
}public class PersonTest {
public static void main(String[] args) {
// 对象的多态性：父类的引用指向子类的对象
Person p = new Man();
// 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
// 如何才能调用子类特有的属性和方法？
// 向下转型：使用强制类型转换符。
Man m1 = (Man)p2;
m1.earnMoney();
m1.isSmoking = true;
//使用强转时，可能出现ClassCastException的异常。所以强转之前，需要通过instanceof进行判断
// Woman w1 = (Woman)p2;
// w1.goShopping();
}
}
多态的笔试题
//考查多态的笔试题目：
public class InterviewTest1 {
public static void main(String[] args) {
Base base = new Sub();
base.add(1, 2, 3);
// Sub s = (Sub)base;
// s.add(1,2,3);
}
}
class Base {
public void add(int a, int... arr) {
System.out.println("base");
}
}
class Sub extends Base {
public void add(int a, int[] arr) {
System.out.println("sub_1");
}
// public void add(int a, int b, int c) {
// System.out.println("sub_2");
// }
}
4148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
