Java_7面向对象的三大特征

1、封装（模块化）

1.问题的引入：

当咱们建立一个类的对象后，能够经过对象.属性的方式，对对象进行赋值。
这里，赋值操做受到属性的数据类型和存储范围的制约，除次以外，没有其余制约条件。

   可是，在实际问题中，咱们每每须要给属性赋值加入额外的限制条件，这个条件又不能在属性声明时体现

，咱们只能经过一个public 方法对属性进行限制条件的添加（get（）,set（））
同时，咱们须要避免用户再使用“对象.属性”进行赋值，则须要将属性声明为私有化。
--》此时，针对属性就体现了封装。

2.封装的思想

（1）类的内部数据操做细节本身完成，不容许外部干涉。仅对外暴露少许的方法用于使用
（2）隐藏对象内部的复杂性。只对外公开简单的接口。便于外界调用，从而提升系统的可扩展性、可维护性。
（3）封装性的设计思想：把该隐藏的隐藏起来，该暴露的暴露出来
例如：

public class Animal{
      int age;//年龄可能被赋为负数，不符合实际
      int legs;//腿有可能被赋为负数或奇数个，不符合实际
}
因此能够给属性设置一个get()和set()方法，来添加限制条件，并获取和设置相应的属性值，以下：

public class Animal{
      private int age;
      private int legs;
    //对属性的设置
  publci void setAge(int age){
     if(age>=0){
      this.age=age;
  }
   //对属性的获取
  public int getAge() {
    return age;
  }
   //对属性的设置
  public void setLegs(int leg){
    if(leg>=0&&leg%2==0){
        legs=leg;
    }else{
        legs=0;
    }
 }
  //对属性的获取
  public int getLegs(){
    return legs;
  }
}

但仅这样还不够，由于用户仍是能够经过“对象.属性”的方式更改属性值，因此，为了不者中状况发生，要将相应的属性私有化，只对外留下public方法来供用户对属性进行使用。

2.封装的体现：

（1）将类的属性私有化，同时提供public方法来获取和设置此属性的值
（2）不对外暴露的私有的方法
（3）单例模式(构造器私有化)

3.封装性的体现，须要权限修饰符（private）的配合

（1）Java的四种权限：
private 缺省 protected public
（2）4种权限能够用来修饰类及类的内部结构(属性、方法、构造器、内部类)
（3）具体的：4种均可以修饰类的内部结构
修饰类：缺省，public

2、类的继承性（代码复用）

1.继承的做用

（1）减小了代码的冗余，提升了代码的复用性
（2）便于功能的扩展
（3）为以后多态性的使用，提供了前提

2.关于继承的描述

一旦子类继承了父类。子类就获取了父类的全部属性和方法，包括私有private方法或属性
证实：
私有属性：经过get()\set（int i）来进行设置和获取
私有方法：将私有方法放在public方法中仍是能够被调用的

3.方法的重写：

（1）子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
（2）子类重写的权限不小于父类（特殊：子类不能重写private方法）
（3）子类重写方法抛出的异常类型不大于父类
（4）返回值类型：
a.父类被重写的方法类型是void,子类重写也是void
b.父类被重写的方法类型是A,子类重写方法能够是A或A的子类
c.父类被重写的方法类型是基本数据类型,子类重写方法也是相同的基本数据类型
（5）不能重写static方法

4.为何要重写：

（1）父类的状况不适用于子类
例如：（圆柱体类继承圆类）圆求面积，但圆柱体求表面积
（2）操做的多样化

5.方法的重载和重写

（1）从定义看：
重载（同一个类中，继承类）：方法名相同，形参列表不一样，返回值能够不一样,权限符能够任意不一样
重写(继承类)：方法名，形参列表相同，返回值，权限符与父类的有关
（2）从编译和运行的角度
重载（不表现为多态性）：容许存在多个同名的方法，编译器根据方法的不一样的参数列表进行区分，对编译器而言，这些同名方法就成了不一样的方法，所以它们的调用地址在编译期间就肯定了
重载：早绑定，静态绑定
重写：能够理解为多态，动态绑定，晚绑定，只有在运行时，才知道调用的对象是父类仍是子类的
(3)static:重载能够，重写不行
static 随着类的加载加载，不能被覆盖
(4)构造器能够重载不能重写

6.super关键字

（1）调用属性，方法
a.通常省略
b.子类、父类有同名属性时，要用super.属性来指明是调用父类的属性
c.子类重写父类方法后，在子类方法中调用父类被重写的方法时，要用super.方法
(2)调用构造器
super(参数1，参数2,...)

3、类的多态性（运行时行为，只有在运行后才能肯定对象）

1.理解：

一个事物的多种形态

2.何为多态性（多态的使用）：动态绑定

（1）对象的多态性：（向上转型）编译看左（父类），运行看右（子类），调用虚拟方法
①父类引用指向子类对象，当调用子父类同名参数的方法时，实际执行的是子类重写父类的方法---虚拟方法调用
虚拟方法：在多态的状况下，父类的方法称为虚拟方法，父类根据赋给它的不一样子类对象，
动态调用属于子类的该方法，这样的方法在编译时是不肯定的
②若是子类没有重写该方法，则执行父类的方法.
③该子类对象不能调用自身的特有方法（编译会看左边的父类）

class Animal{
    public void walk(){
       System.out.println("动物跑");
    }
}
class Cat extends Animal {
    @Override
    public void walk() {
        System.out.println("喵喵走路");
    }
public class AnimalTest {
    public static void main(String[] args) {
         Animal cat=new Cat();//父类引用指向子类对象
          cat.walk();//调用walk()方法，执行的是子类重写的walk方法
     }
}

(2)对象的多态性只适用于方法不适用于属性，属性都看左边的父类

3.多态的使用前提：

（1）类的继承关系
（2）要有方法的重写

4.为何有多态性：

能够经过传入不一样的对象来控制不一样的特征结果

5.为何有了对象的多态性后，子类特有的方法和属性不能调用

内存中其实是加载了子类特有的属性和方法，可是因为变量声明为父类类型，
致使编译时，只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用

如何调用子类特有的属性和方法：

强制类型转换，（向下转型）将父类引用指向的对象转为为子类类型，可能会出现ClassCastException异常，
解决方法：instanceof
（1）a instanceof A:判断对象a是不是A的实例,若是true就向下转型

Animal cat=new Cat();
if(cat instanceof Cat){
    Cat cat1=(Cat)cat;
    cat1.eat();
}

（2）若是 a instanceof A:为true，a instanceof B也为true，则B是A的父类