面向对象编程03：封装、继承、多态

面向对象编程03：封装、继承、多态

封装

• 该露的露、该藏的藏
  • 设计程序要追求“高内聚、低耦合”。
  • 高内聚就是类的内部数据操作细节由自己完成，不允许外部干涉；
  • 低耦合：仅仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常我们应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这被称为“信息隐藏”。
• 理解封装，记住这句话就够了：属性私有，get/set

下面我们来看看封装的代码实例：

public class Student {
    //属性私有:private
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //提供一些可以操作这个属性的方法：public的get、set方法
    //Alt+Enter快捷创建get和set方法

    //get 获得这个数据
    //set 设置值
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<0||age>120){
            System.out.println("invalid number");
        }else{
            this.age= age;
        }

    }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("David");//将David通过setName方法赋值给name.
        System.out.println(student.getName());
        student.setAge(20);
        System.out.println(student.getAge());

    }
}
输出结果：
David
20

封装的好处：

1. 提高程序的安全性。保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加了系统的可维护性

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”。子类是父类的扩展。
• JAVA中类只有单继承，没有多继承！
• 继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类：一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示。
• 子类和父类之间从意义上讲应该具有“is a”的关系。

下面我们来看一个简单的继承的例子：

//Java中所有的类都默认直接或间接继承object类
//父类： Person
 class Person /*extends object*/ {
    int money = 10_000_000;
    public void say(){
        System.out.println("说了一句话");
    }
}
//子类：Student
//继承了父类的所有方法
 class Student extends Person {
}
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//say是父类Person的方法
        System.out.println(student.money);//money是父类Person中的变量
    }
}

object类

在Java中所有的类都默认直接或间接继承object类。

class Person /*extends object*/ {
}

java的Object类方法如下：

1. getClass方法

获取运行时类型,返回值为Class对象

2. hashCode方法

返回该对象的哈希码值，是为了提高哈希表的性能（HashTable）

3. equals方法

判断两个对象是否相等，在Object源码中equals就是使用去判断，所以在Object中equals是等价于的，但是在String及某些类对equals进行了重写，实现不同的比较。

4. clone方法

主要是JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递，我们有时候不希望在方法里将参数改变，这时就需要在类中复写clone方法。

如果在clone方法中调用super.clone()方法需要实现Cloneable接口,否则会抛出CloneNotSupportedException。

此方法只实现了一个浅层拷贝,对于基本类型字段成功拷贝,但是如果是嵌套对象,只做了赋值,也就是只把地址拷贝了,所以没有成功拷贝,需要自己重写clone方法进行深度拷贝。

5.toString方法

返回一个String字符串,用于描述当前对象的信息,可以重写返回对自己有用的信息，默认返回的是当前对象的类名+hashCode的16进制数字。

6. wait方法

多线程时用到的方法，作用是让当前线程进入等待状态，同时也会让当前线程释放它所持有的锁。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，当前线程被唤醒

7. notify方法

多线程时用到的方法，唤醒该对象等待的某个线程

8. notifyAll方法

多线程时用到的方法，唤醒该对象等待的所有线程

9.finalize

对象在被GC释放之前一定会调用finalize方法，对象被释放前最后的挣扎,因为无法确定该方法什么时候被调用，很少使用。

super

1. super关键字指向父类：

//父类： Person
 class Person {
     int age = 60;
    public void say(){
        System.out.println("Person说了一句话");
    }
}
//子类：Student
//继承了父类的所有方法
 class Student extends Person{
    public void print() {
        System.out.println("Peosin is"+ super.age);
        System.out.println("Student");
        super.say();//
    }
}
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.print();
    }
}
输出结果：
Person is 60
Student
Person说了一句话

2. 调用子类构造器时相当于提前执行了一行隐藏代码：super（）；：

//父类： Person
 class Person {
    public Person() {
        System.out.println("Person无参构造已执行");
    }
}
//子类：Student
//继承了父类的所有方法
 class Student extends Person{
    //super();
     public Student() {
        System.out.println("Student无参构造已执行");
    }
}
/**
 * @author 15065170282
 */
public class Application{
    public static void main(String[] args) {
        Student student = new Student();
    }
}
输出结果：
Person无参构造已执行
Student无参构造已执行

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个；
2. super只能出现在子类的方法或者构造方法中；
3. super和this不能同时调用构造方法！

super VS this:

1. 二者代表对象不同：

   this: 代表调用者本身

   super: 代表父类应用

2. 使用前提不同：

   this: 不用继承就能直接使用

   super： 只能在继承条件下使用

3. 构造方法：

   this();代表本类的构造

   super();代表父类的构造

方法重写

1. 前提：方法重写需要有继承关系，即子类重写了父类的***方法***，方法名、参数都一致但是方法体不同

2. 方法重写只针对于实例方法,静态方法不存在重写

3. 方法重写只针对于public关键字修饰的方法,private修饰的无法被继承

4. 参数列表必须相同（不同就变成重载了）

5. 修饰符：范围可以扩大但不能缩小： public>protected>default>private

6. 抛出的异常范围可以被缩小但是不能扩大：

7. 为什么需要重写？

   因为有时父类的功能子类不一定需要或不一定满足；

8. 快捷键（IDEA中）：Alt + Insert

class Person{
    public void say(){
        System.out.println("父亲说了一句话");
    }

}
class Student extends Person{
    @Override
    public void say() {
        System.out.println("Student 重写了Person的方法");
    }
}
/**
 * @author 15065170282
 */
public class OverrideTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.say();
        Student student = new Student();
        student.say();
    }
}

多态

• 同一方法可以根据发送对象的不同采取多种不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向该对象的引用类型有很多
• 多态存在的条件：
  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象

下面来看一个多态的实例：

package JavaSe.oop.demo07;



class Person{
    public void run(){
        System.out.println("run");
    }


}
class Student extends Person{
    @Override
    public void run() {
        System.out.println("子类重写了父类的run方法");
    }
    public void eat(){
        System.out.println("eat");
    }
}

/**
 * @ClassName Application
 * @author 15065170282
 **/
public class Application {
    public static void main(String[] args) {
        //一个对象的实现类是确定的：new Student(); new Person();
        //但是引用类不能确定：父类的引用指向子类

        //Student能调用的方法都是自己的或者是继承父类的！
        Student s1 = new Student();
        //Person父类可以指向子类但是不能调用子类独有的方法；
        Person s2=new Student();
        Object s3=new Student();
        //对象能执行哪些方法取决于引用类的类型，和实现类无关；
        s1.eat();
        ((Student) s2).eat();//类型转换
         s1.run();
         s2.run();


    }
}
输出结果：
eat
eat
子类重写了父类的run方法
子类重写了父类的run方法

多态的注意事项：

1. 多态指的是方法的多态，属性没有多态一说。

2. 父类和子类因为有联系（继承关系）才能进行转换

   类型转换异常：ClassCastException!

3. 存在条件： 继承关系，方法需要重写，父类引用指向子类对象： Father F1 = new Son();

无法重写：

1. static方法，属于类，不属于实例；
2. final常量；
3. private方法；

instanceof关键字

instanceof 关键字用于判断两个类之间是否有父子关系。

public class InstanceOfTest {
    public static void main(String[] args) {
        //System.out.println(X instanceof Y);//能否编译通过取决于X与Y之间是否有关
        //object-->Person-->Student
        //object-->Person-->Teacher
        Object o = new Object();
        System.out.println(o instanceof Student);
        System.out.println(o instanceof Person);
        System.out.println(o instanceof Object);
        System.out.println(o instanceof Teacher);
        System.out.println(o instanceof String);
        System.out.println("====================================");
        Person person = new Person();
        System.out.println(person instanceof Student);
        System.out.println(person  instanceof Person);
        System.out.println(person  instanceof Object);
        System.out.println(person  instanceof Teacher);
        //编译时就会报错：System.out.println(person  instanceof String);
        System.out.println("====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student  instanceof Object);
        //编译时就会报错：System.out.println(student  instanceof Teacher);
        //编译时就会报错：System.out.println(student  instanceof String);
    }
}
输出结果：
false
false
true
false
false
====================================
false
true
true
false
====================================
true
true
true

父类与子类之间的类型转换

1. 父类引用指向子类的对象： Father f = new Son();
2. 子类转换成父类，向上转型；
3. 父类转换成子类，向下转型：强制转换
4. 作用：方便方法的调用，减少代码的重复

下面来看父子类类型转换的代码实例：

class Test{

}
class TestSon extends Test{
    public void go(){
        System.out.println("go");
    }
}
/**
 * @ClassName Application
 * @Author ${17368877923}
 **/
public class Application {
    public static void main(String[] args) {
        //类型之间的转化： 父  子
        //高------>低需要强转
        //低------>高可以直接转
        Test test = new TestSon();
        new  TestSon().go();//对象.方法
        //test.go();
        TestSon testSon = (TestSon) test;
//可以对比int testSon=3; double test =3.0; int testSen=(int) test;高到低强转 
// testSon将test对象转换为TestSon类型，我们就可以使用TestSon类型的方法了
        testSon.go();
        ((TestSon) test).go();
    }
}