面向对象基础认识3

目录

面向对象特征--继承：

java中的继承：

继承的好处：

何时使用继承：

继承的语法：

继承性的细节：

扩展：

方法的重写(OverRide)：

方法重写的规则

@Override 使用说明：

继承中的构造方法

抽象类

抽象方法:

面向对象特征--多态：

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

向上转型

多态性的好处：提高代码的扩展性

多态环境下对成员方法的调用

向下转型

final关键字：

接口：

生活中的接口

可以使用Java接口来实现​编辑

面向接口编程

认识一下接口

接口的定义与使用

接口的特性：

面向对象特征--继承：

生活中的继承：
财产继承：绿化继承：

java中的继承：

猫类：

狗类：

猫继承动物类属性 && 狗继承动物类属性

继承的好处：

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

何时使用继承：

符合is-a关系的设计,可以使用继承

例如:

猫是动物 The cat is an animal.

狗是动物 The dog is an animals.

继承的语法：

通过 extends 关键字，可以声明一个类B继承另外一个类A，定义格式如下：

[修饰符] class 类A {

...

}

[修饰符] class 类B extends 类A {

...

}

类B，称为子类/派生类

类A，称为父类/基类

具体实例：

public class Animal{ public String name; public int age; public void eat(){ System.out.println("动物在吃东西"); } } public class Cat extends Animal{ public void eat(){ System.out.println("小猫在吃东西"); } public void catchMouse(){ System.out.println("小猫在抓老鼠"); } } public class Dog extends Animal{ public void eat(){ System.out.println("小狗在吃东西"); } public void lookHome(){ System.out.println("小狗在守家"); } }

继承性的细节：

• 子类会继承父类所有的实例变量和实例方法
• 子类不能直接访问父类中私有的(private)的成员变量和方法
• 在Java 中，继承的关键字用的是“extends”，表示子类是对父类的扩展
• Java支持多层继承(继承体系)
• 一个父类可以同时拥有多个子类
• Java只支持单继承，不支持多重继承

• 扩展：

• 类 java.lang.Object,是类层次结构的根类,即所有其它类的父类,每个类都使用 Object作为超类。
  当一个类没有显示的继承其他类时,默认继承Object类。

方法的重写(OverRide)：

当父类的方法功能实现不能满足子类需求时,可以对方法进行重写( override).

子类可以对从父类中继承来的方法进行改造，我在程序执行时，子类的方法将覆盖父类的方法。们称为方法的重写也称为方法的覆盖。

注意：构造方法,静态方法不能重写,成员变量不存在重写

方法重写的规则

1 . 子类重写的方法必须和父类被重写的方法名称,参数列表相同。

2 . 子类重写的方法的返回值类型与父类保存一致。

3 . 子类重写的方法使用的访问权限不能小于父类被重写方法的访问权限。

注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写

4 . 子类方法抛出的异常不能大于父类被重写方法的异常

@Override 使用说明：

@Override 是java中定义的注解标签,用来进行标记

写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

super关键字

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性

super可用于调用父类中定义的成员方法

super可用于在子类构造器中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员super的追溯不仅限于直接父类还可以是父类的父类

super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

误区: 不要把super误认为是父类对象,在创建子类对象时,不会创建父类对象.

只会将父类中的信息加载到子类对象中存储.

继承中的构造方法

• 子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)”的方式调用父类指定的构造方法。
• 规定super(形参列表)，必须声明在构造器的首行。
• 如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器默认调用super()，即调用父类中空参的构造器。
• 这么做是为了保证先对父类成员进行初始化。

开发中常见错误：

如果子类构造器中既未显式调用父类或本类的构造器,且父类中又没有空参的构造器,则编译出错。

抽象类

抽象方法:

• 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现.抽象方法必须用abstract关键字进行修饰.
• 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
  
• 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和
• 构造方法。
• 用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须
• 定义成抽象类。

特点:

1. 抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，
2. 所以不能用抽象类创建对象。
3. 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现
4. 其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否
5. 则，该类也必须声明为抽象类。

使用关键字abstract定义抽象类，一般语法：

[访问权限]abstract class类名 {

成员列表

}

具体实例：

public abstract class Shapes { public abstract void draw(); }

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

面向对象特征--多态：

多态：

父类引用指向子类对象，从而产生多种形态

Animal dog = new Dog();

Animal cat = new Cat();

同一种事物，在不同时刻表现不同状态

二者存在直接或者间接的继承关系时，父类引用指向子类的对象，即形成多态。

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

向上转型

多态性的好处：提高代码的扩展性

多态环境下对成员方法的调用

向下转型

父类引用仅能访问父类所声明的属性和方法，不能访问子类独有的属性和方法。

向下转型的作用是：为了使用子类中的特有方法。

思考：

public class Animal{ public String name; public int age; public void eat(){ System.out.println("动物在吃东西"); } } public class Cat extends Animal{ public void eat(){ System.out.println("小猫在吃东西"); } public void catchMouse(){ System.out.println("小猫在抓老鼠"); } } public class Dog extends Animal{ public void eat(){ System.out.println("小狗在吃东西"); } public void lookHome(){ System.out.println("小狗在守家"); } }

在下面代码的基础上思考下面的俩段代码的区别

Cat cat=new Cat();

Animal cat=new Cat();

。。。。结尾有答案

final关键字：

final 用于修饰类,方法,参数，和属性

类:不能被定义为抽象类或是接口,不可被继承

方法:子类里不可以重写

参数:参数值在方法中不可被修改

属性:定义时就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改

具体实例：

// 1. final 修饰类：这个类不能被其他类继承 final class Animal { // 2. final 修饰成员变量：常量，值不能修改 public final String TYPE = "生物"; // 3. final 修饰方法：子类不能重写这个方法 public final void eat() { System.out.println("动物在吃东西"); } }

接口：

生活中的接口

可以使用Java接口来实现

面向接口编程

从本质上讲，接口是一种特殊的抽象类，这种抽象类中包含抽象方法。

认识一下接口

接口的定义与使用

接口的定义：使用 interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1 ,….其他的接口名n]{

// 声明常量 抽象方法 静态方法 默认方法

}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2 ……{ }

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2 ……{ }

定义动物接口：

// 定义动物接口 interface Animal { // 接口中的方法默认是 public abstract void eat(); void sleep(); }

类实现接口：

// 猫 实现 动物接口 class Cat implements Animal{ @Override public void eat() { System.out.println("小猫吃鱼"); } @Override public void sleep() { System.out.println("小猫白天睡觉"); } } // 狗 实现 动物接口 class Dog implements Animal{ @Override public void eat() { System.out.println("小狗吃骨头"); } @Override public void sleep() { System.out.println("小狗晚上睡觉"); } }

测试类运行：

public class InterfaceTest { public static void main(String[] args) { // 多态写法：接口引用指向实现类对象 Animal cat = new Cat(); cat.eat(); cat.sleep(); System.out.println("--------"); Animal dog = new Dog(); dog.eat(); dog.sleep(); } }

接口的特性：

• 接口是隐式抽象的，主要用来定义功能.
• 接口中可以定义静态常量,抽象方法,静态方法,默认方法.
• 一个接口能继承其它多个接口.
• 接口不能实例化对象.
• 接口是要被类实现,一个接口可以被多个实现
• 当类实现接口的时候，类要实现接口中所有的抽象方法,否则，该类必须声明为抽象的类.
• 接口与实现类之间存在多态性

思考解惑：

Cat cat=new Cat();// 普通创建对象

Animal cat=new Cat();//向上转型/多态

总结：

1. Cat cat = new Cat()：子类引用指向子类对象，能用所有方法，无多态；
2. Animal cat = new Cat()：父类引用指向子类对象，只能用父类方法，不能用子类独有方法，运行执行子类重写逻辑，是多态；
3. 核心规则：编译看左边，运行看右边