6月30日

指针可以指向对象，前提是：

在没有继承关系之前

指针的数据类型与对象的数据类型必须一样

在有了继承关系之后

指针的数据类型可以与对象的数据类型不一样

如果存在继承关系，那么父类类型的指针可以指向子类类型的对象

Object 类型可以指向任意类型这种

将子类对象赋给父类指针的语法称为“向上转型”，隐式的

   继承是向上转型的前提

   向上转型是多态的前提

   向上转型的副作用：指针无法访问下级对象的成员

“向下转型”需要显式的强制转换，通常伴随着instanceof做类型判断

指针向下转型为下级类型，就又可以访问下级对象中的成员

如果使用了向上转型实现了多态指针，在用指针操作对象的时候又不想向下转型，可以使用方法重写来实现

思考：Animal类型的指针为什么不能调用show()方法，因为Animal类中没有show()方法

1. 在父类Animal中添加一个show()方法

animalArray[i].show();此时animalArray[i]不需要向下转型也可以调用

1. 当子类中出现与父类中的同名方法的时候，就存在方法重写的关系

存在满足重写关系的方法的时候，会自动向下调用子类重写的方法

abstract关键字:抽象

可以修饰成员方法和类

成员方法被abstract修饰后，称为抽象方法/虚方法，没有{}方法体

类被abstract修饰后，称为抽象类，不可以被实例化

抽象方法必须出现在抽象类中，而抽象类中不一定必须有抽象方法

例如：Animal必须被abstract修饰，成为抽象类

Animal animal = new Animal();  //报错，抽象类不可用被实例化

抽象类天生就是父类，天生就是被子类继承的

子类继承抽象类的时候，必须强制重写父类的抽象方法

子类继承父类的时候，如果父类中有抽象方法，子类不许重写，除非把子类也变为抽象类，让子类的子类去重写

例如：Dog，Cat，Pig这三个子类继承Animal父类

Dog dog = new Dog();  //一定正确

Cat cat = new Cat();  //一定正确

Pig pig = new Pig();  //一定正确

Animal animal1 = new Dog();  //如果有继承关系Dog extends Animal就正确

Animal animal2 = new Cat();  //如果有继承关系Dog extends Animal就正确

Animal animal3 = new Pig();  //如果有继承关系Dog extends Animal就正确

Object object1 = new Dog();//一定正确

Object object2 = new Cat();//一定正确

Object object3 = new Pig();//一定正确

Dog dog = new Cat();  //不正确

Cat cat = new Pig();   //不正确

越向上转型，不可访问的对象越多

越向上转型，指针的数据类型越抽象

多态，面向对象的第三大特性

与多态相反的是单态

多态的指针（指针的形态是抽象的）

单态的指针（指针的形态是具体的）

多态的数组，数组元素是指针，指针多态

单态的数组，数组元素是指针，指针单态

ClassCastException：类型转换异常

面向对象整理

面向过程和面向对象的区别

面向过程编程思想不考虑封装、继承、多态这些事情，直接定义数据为静态变量，用静态函数操作，面向过程编程，代码不具有可复用性和可扩展性

向对象编程思想需要先抽象出实体的结构，并用类进行封装，用成员变量表达实体的属性，用成员方法封装对实体属性的操作。提供构造方法构造对象，基于对象编程。面向对象编程，代码具有可复用性和可扩展性

举例：实现汽车租赁系统

面向过程的思想：

定义多个静态数组，存储汽车各项数据，直接定义静态函数实现各种业务过程

面向对象的思想

先抽出汽车实体的结构，并使用汽车类进行汽车类进行封装，然后创建汽车数组存储汽车实体的数据，在考虑业务功能的实现

面向对象的三大特征

1.封装

2.继承

3.多态

第一特性：封装

用成员变量来描述对象的属性，并用private进行私有化封装，不对外暴露对象的属性。防止外部对属性误操作。

用成员方法来封装对属性的操作，并暴露给外部调用。典型的就是setter和getter,一个是提供给外部进行属性设置，一个时提供给外部读取外部读取属性的值

第二特性：继承

1.继承是Java中类与类之间的一种关系父类

2.继承的关键字是extends

3.发生继承的类称为子类，被继承的类称为父类

4.Java不支持多继承，只支持单继承，但支持多级继承，一个类只能继承一个直接父类，一个父类可以有多个子类

5.如果一个类没有显式地继承父类，则隐式继承object类

6.子类可以继承父类的非私有（非private修饰）成员    

7.父类的构造方法子类不能继承，但可以使用super()调用

8.父类的静态成员与继承无关

9.如果父类中有抽象方法，子类必须要重写，除非子类也是抽象类，让子类的子类区重写（实现）

第三特性：多态

先有继承而后有多态，多态的反义词是单态

1．指针的多态（数组的多态、参数的多态、返回值的多态归根到底都是指针的多态）

如果指针是具体的子类类型，则指针是单态指针，只能指向具体的子类对象

如果指针是具体的父类类型，则指针是多态指针，可以指向任意的子类对象

1. 方法的多态（1.基于重载实现 2.基于重写实现）

   重载是编译时多态的体现

   重写是运行时多态的体现

重载和重写的区别

重载、重写都是方法多态的体现

重载overload是编译时多态的体现

1.重载发生在同一个类中，Java允许一个类中多个方法同名存在，但必须满足重载的要求

2.重载的要求：方法名相同，但是方法的参数列表不同（可以是参数个数不同，或者是参数类型不同）

3.静态方法、构造方法、成员方法都可以重载

重写override是运行时多态的体现

1.重写发生在子类和父类之间，子类重写父类的方法，其目的是：当使用父类的指针调用子类方法的时候，可以无需向下转型

2.子类方法与父类方法同名，访问修饰符要大于等于父类方法

3.参数的个数必须和父类一样，参数类型可以小于等于父类方法的参数类型

4.返回值类型可以小于等于父类方法的的返回值类型

抽象类和抽象方法的关系

1.抽象类和抽象方法都需要abstract关键字修饰

2.抽象方法必须出现在抽象类中

3.抽象方法中可以有抽象方法，也可以没有

普通类和抽象类的区别

普通类可以实例化，也可以被继承

抽象类不可以实例化，只能被继承         

实例化就是  new构造方法()  创建对象

向上转型和向下转型的区别

向上转型

1. 将子类对象/指针赋给父类指针的语法称为“向上转型”，隐式的
2. 继承是向上转型的前提，向上转型的目的是为了实现多态的指针
3. 向上转型的副作用，指针无法访问下级对象中的成员（除非发生了重写）

向下转型

1.将父类型指针赋给子类型指针的语法称为“向下转型”，需要显式的强制转换，通常伴随着instanceof做类型判断，否则可能会出现ClassCastExpection（类型转换异常）

2.指针向下转型为子类型，就可以访问子类中特有成员了（成员方法）

访问权限修饰符

修饰符		当前类	同包	子类	其他包
Private	私有的	可见√	不可见×	不可见×	不可见×
(deflault)	默认的	可见√	可见√	不可见×	不可见×
protected	受保护的	可见√	可见√	可见√	不可见×
public	共有的	可见√	可见√	可见√	可见√

Private的特点：只有本类可见

(deflaut)的特点：只有同包可见

Protected的特点：只有子类可见

Public的特点：任何地方可见

抽象类和接口的区别

接口

1.接口也是源代码文件

  定义类的关键字是class,

定义接口的关键字是interface

2.接口的出现让Java也能实现多继承，一个类只能继承一个父类，但可以继承多个接口

   子类继承/扩展父类，关键字是extends

   子类继承/实现/扩展接口，关键字是implements

1. 接口和抽象类比较

   相同点：

1. 都可以作为指针的类型，实现多态指针
2. 都不可以实例化

   不同点：

      1).抽象类用class定义，接口用interface定义

      2).抽象类用extends继承，接口用implments定义

      3).类只能单继承，接口可以实现多继承

      4).虽然两者都不可以实例化，但是抽象类可以构造方法，接口不可以有构造方法

      5).抽象类可以有抽象方法，也可以有具体方法，接口只能有抽象方法，而且接口中所有的方法默认是”public abstact”修饰的

      6).抽象类可以有成员变量，接口不能有成员变量，只能有静态常量

如何理解接口？如何理解面向接口编程？