Java学习笔记（4）——面对对象（三大特性）

Java学习笔记（4）——面对对象（三大特性）

面向对象的大特征：封装性、继承性、多态性

1 封装

1.1 概念（what？）

隐藏对象内部的复杂性，只对外公开简单的接口。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

1.2 作用（why？）

• 高内聚，低耦合。
  高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  低耦合 ：仅对外暴露少量的方法用于使用
• 便于外界调用，从而提高系统的可扩展性、可维护性

1.3 使用说明（how？）

**通过Java规定的四种权限修饰符实现！

• 权限从小到大顺序为：** private < 缺省 < protected < public
  

• 4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

• 修饰类的话，只能使用：缺省、public

2 继承

2.1 介绍（what）

• 体现： 一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
• 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。
• extends：延展、扩展

2.2 作用（why）

• 减少了代码的冗余，提高了代码的复用性
• 便于功能的扩展
• 为之后多态性的使用，提供了前提

2.3 使用说明（how）

• 格式：class A extends B{}； A:子类、派生类、subclass；B:父类、超类、基类、superclass

1. 一个类可以被多个子类继承。
2. Java中类的单继承性：一个类只能有一个父类
3. 子父类是相对的概念。
4. 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5. 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
6. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类。所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类意味着，所有的java类具有java.lang.Object类声明的功能。

2.4 方法的重写

• 定义：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.
• 应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法

class Circle{
public double findArea(){}//求面积
}
class Cylinder extends Circle{
public double findArea(){}//求表面积
}
***************
class Account{
public boolean withdraw(double amt){}
}
class CheckAccount extends Account{
public boolean withdraw(double amt){}
}

• 方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
  //方法体
  }
• 约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况：子类不能重写父类中声明为private权限的方法
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写，要么都声明为static的（不是重写)。

3 多态

• 定义：对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
• 多态性的使用：虚拟方法调用；有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。总结：编译，看左边；运行，看右边。
• 多态性的使用前提：① 类的继承关系 ② 方法的重写
• 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

3.1向上转型和向下转型

举个例子：有2个类，Person是父类，Man类继承自 Person

Person p2 = new Man();//向上转型
Man m1 = (Man)p2//向下转型

向上转型：多态

3.1.1向下转型

• why？
  有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
• how?
  使用强制类型转换符：()
• 注意事项

1. 使用强转时，可能出现ClassCastException的异常。
2. 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型

instanceof的使用：
① a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。

 class PersonTest {
    public static void main(String[] args) {
        Person6 p1 = new Person6();
        p1.eat();
        Man man = new Man();
        man.eat();
        man.age = 25;
        man.earnMoney();
        //*************************************************
        System.out.println("*******************");
        //对象的多态性：父类的引用指向子类的对象
        Person6 p2 = new Man();
//		Person p3 = new Woman();
        //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
        p2.eat();
        p2.walk();
//		p2.earnMoney();
        System.out.println(p2.id);//1001

        System.out.println("****************************");
        //不能调用子类所特有的方法、属性：编译时，p2是Person类型。
        p2.name = "Tom";
//		p2.earnMoney();
//		p2.isSmoking = true;
        //有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
        //编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
        //如何才能调用子类特有的属性和方法？
        //向下转型：使用强制类型转换符。
        Man m1 = (Man)p2;
        m1.earnMoney();
        m1.isSmoking = true;

        //使用强转时，可能出现ClassCastException的异常。
//		Woman w1 = (Woman)p2;
//		w1.goShopping();

        /*
         * instanceof关键字的使用
         *
         * a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
         *
         *
         *  使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
         *  进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
         *
         *  如果 a instanceof A返回true,则 a instanceof B也返回true.
         *  其中，类B是类A的父类。
         */
        if(p2 instanceof Woman){
            Woman w1 = (Woman)p2;
            w1.goShopping();
            System.out.println("******Woman******");
        }
        if(p2 instanceof Man){
            Man m2 = (Man)p2;
            m2.earnMoney();
            System.out.println("******Man******");
        }
        if(p2 instanceof Person6){
            System.out.println("******Person******");
        }
        if(p2 instanceof Object){
            System.out.println("******Object******");
        }
//		if(p2 instanceof String){
//
//		}
        //练习：
        //问题一：编译时通过，运行时不通过
        //举例一：
//		Person p3 = new Woman();
//		Man m3 = (Man)p3;
        //举例二：
//		Person p4 = new Person();
//		Man m4 = (Man)p4;
        //问题二：编译通过，运行时也通过
//		Object obj = new Woman();
//		Person p = (Person)obj;
        //问题三：编译不通过
//		Man m5 = new Woman();
//		String str = new Date();
//		Object o = new Date();
//		String str1 = (String)o;
    }
}

//class Order{
//
//}

class Person6 {
    String name;
    int age;
    int id = 1001;
    public void eat(){
        System.out.println("人：吃饭");
    }
    public void walk(){
        System.out.println("人：走路");
    }

}

class Woman extends Person6{
    boolean isBeauty;
    public void goShopping(){
        System.out.println("女人喜欢购物");
    }
    public void eat(){
        System.out.println("女人少吃，为了减肥");
    }
    public void walk(){
        System.out.println("女人窈窕的走路");
    }
}


class Man extends Person6{

    boolean isSmoking;
    int id = 1002;
    public void earnMoney(){
        System.out.println("男人负责挣钱养家");
    }
    public void eat(){
        System.out.println("男人多吃肉，长肌肉");
    }
    public void walk(){
        System.out.println("男人霸气的走路");
    }

}