02-2面向对象三大特性

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

1封装思想

概述：是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性、可维护性

原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法

好处：通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性
程序设计追求“高内聚，低耦合”。

• 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合 ：仅对外暴露少量的方法用于使用。

注意：每个对象都保存这描述当前类的信息，对象的信息的改变必须通过调用方法来实现，否则不满足封装思想

封装性的体现：当我们调用JavaAPI时，只需要知道对应的方法名和参数，不需要知道源码实现的细节

package com.nie.oop.packaging;

//隐藏属性，提供对应的getXxx()/setXxx()方法
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

JavaBean：是一种Java语言写成的可重用组件。

规范：

• 类是公共的
• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

上述Person类就是JavaBean

2继承思想

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

此处的多个类称为子类(派生类)，单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”

特点：

• 继承的出现减少了代码冗余，提高了代码的复用性。
• 继承的出现，更有利于功能的扩展。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

• 子类继承了父类，就继承了父类的方法和属性。

• 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

• 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

语法规则：class Subclass extends SuperClass{ }

注意：不要仅为了获取其他类中某个功能而去继承

继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

3多态思想

多态性，是面向对象中最重要的概念，在Java中的体现：

对象的多态性：父类的引用指向子类的对象，可以直接应用在抽象类和接口上

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性

多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法） “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）

多态是运行时行为

对象的多态 在Java中,子类的对象可以替代父类的对象使用

• 一个变量只能有一种确定的数据类型
• 一个引用类型变量可能指向(引用)多种不同类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型。

作用：提高了代码的通用性，常称作接口重用

使用前提：①需要存在继承或者实现关系②有方法的重写

成员变量不具备多态性，只看引用变量所声明的类。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

public class Person {
    int age;
    String name;
    public void getInfo(){
        System.out.println("Person...getInfo");
    }
}


class Student extends Person{
    String school;
    public void getInfo(){
        System.out.println("Student...getInfo");
    }
}
public class PersonTest {
    public static void main(String[] args) {
        Person p = new Student();
        p.school;//无法编译通过
        //属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误
    }
}

虚拟方法调用(Virtual Method Invocation)
正常的方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下) 子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。 

Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型
动态绑定：编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类 的getInfo()方法。

一个面试题

 1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边

class Base {
	int count = 10;

	public void display() {
		System.out.println(this.count);
	}
}

class Sub extends Base {
	int count = 20;

	public void display() {
		System.out.println(this.count);
	}
}

public class FieldMethodTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
		
		Base b = s;//多态性
		//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
		System.out.println(b == s);//true
		System.out.println(b.count);//10
		b.display();//20
	}
}

开发中不要子父类中不要出现同名的属性 

4抽象性思想

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

• 用abstract关键字来修饰一个类，这个类叫做抽象类。
• 用abstract来修饰一个方法，该方法叫做抽象方法。
• 抽象方法：只有方法的声明，没有方法的实现。以分号结束：比如：public abstract void talk();
• 含有抽象方法的类必须被声明为抽象类。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
• 不能用abstract修饰变量、代码块、构造器；
• 不能用abstract修饰私有方法、静态方法、final的方法、final的类

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

5接口思想 

接口概述

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

接口(interface)是抽象方法和常量值定义的集合。

接口的特点：

• 用interface来定义。
• 接口中的所有成员变量都默认是由public static final修饰的。
• 接口中的所有抽象方法都默认是由public abstract修饰的。
• 接口中没有构造器。
• 接口采用多继承机制。

定义Java类的语法格式：先写extends，后写implements

class SubClass extends SuperClass implements InterfaceA{ }

一个类可以实现多个接口，接口也可以继承其它接口。

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。

接口的主要用途就是被实现类实现。（面向接口编程）

与继承关系类似，接口与实现类之间存在多态性

接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

接口的具体使用体现多态性，

开发中要面向接口（抽象）编程

jdk7以前：只能定义全局常量和抽象方法

• 全局常量：public static final的.但是书写时，可以省略不写
• 抽象方法：public abstract

interface Flyable{
	
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();		
}

Jdk8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

有了这个规则，接口越来越像类靠拢

public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	//默认方法
	public default void method2(){
		System.out.println("CompareA：上海");
	}
	
	default void method3(){
		System.out.println("CompareA：上海");
	}
}