面向对象3 -优快云博客

本文链接：https://blog.youkuaiyun.com/2401_87401600/article/details/145729252

一.面向对象特征--继承

继承即使父与子之间的关系，比如生活中，儿子继承父亲的遗产

1.继承的概念

Java中的继承就是：多个类中存在的相同属性和行为，那么将这些内容抽取到单独的一个类中，那么，多个类中就不需要再定义这些属性和行为，只要在需要继承那个单独的类，直接进行调用

例如

动物是一个大类，而猫类和狗类都有年龄、名字、吃这些属性和行为就可以建立一个动物大类，在猫类和狗类中继承这个动物类

2.继承的好处

（1）.继承的出现减少了代码冗余，提高了代码的复用性

（2）.继承的出现，有利于功能的扩展

（3）.继承的出现让类与类之间产生了is-a的关系，为多态的使用提供了前提

3.何时使用继承

当符合is-a关系设计，可以使用继承

例如：猫是动物

狗是动物

4.继承的语法

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

[修饰符]class类A{

.......

}

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

......

}

5.继承的细节

（1）.子类会继承父类所有的实例变量和实例方法

（2）.子类不能直接访问父类中私有的（private）的成员变量和方法

（3）.在Java中，继承的关键字用的是"extends",表示子类是对父类的扩展

（4）.Java支持多层继承（继承体系）

（5）.一个父类可以同时拥有多个子类

（6）.Java只支持单继承，不支持多重继承

package jicheng.demo1;

/*  继承：
      当满足什么是什么（is-a）关系时，就可以使用继承语法
      把同类中公共的一些属性和行为提取到一个父类中
      再让子类继承父类，子类就可以拥有父类中的非私有功能
      可以提高代码的复用性
      例如 狗是动物  猫是动物，就可以提取一个动物父类

      在Java语言中，提供一个特别的类---java.long.Object是类系统的最顶级类
      所有类都直接或间接的继承了Object类

      如果一个类没有显示继承其他类，那么这个类默认继承Object
* */
public class Animal {
    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;
    }
    public void eat(){
        System.out.println("吃东西");
    }
}



package jicheng.demo1;

public class Cat extends Animal{
    public void catchMouse (){
        System.out.println("猫捉老鼠");
    }
}



public class Dog extends Animal {
public void lookHome(){
        System.out.println("狗看家");
    }
}

6.Object类

类 java.lang.Object,是类层次结构的根类，即所有其它类的父类。每个类都使用 Object作为超类。

当一个类没有显示的继承其他类时,默认继承Object类。

7.方法的重写

当父类的方法功能实现不能满足子类需求时 , 可以对方法进行重写 ( override). 子类可以对从父类中继承来的方法进行改造，我在程序执行时，子类的方法将覆盖父类的方法。们称为方法的重写也称为方法的覆盖。

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

（1）.重新的规则

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

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

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

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

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

(2).@Override使用说明：

@Override是java中定义的注解标签,用来进行标记(进阶部分细讲)

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

(3).super关键字

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

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

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

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

注意：

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

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

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

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

八.继承中的构造方法

1. 子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)”

的方式调用父类指定的构造方法。

2. 规定super(形参列表)，必须声明在构造器的首行。

3. 如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器

默认调用super()，即调用父类中空参的构造器。

4. 这么做是为了保证先对父类成员进行初始化。

开发中常见错误：

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

二.抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。

用 abstract 修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

1.特点:

抽象类不能被实例化，但可以有构造方法 , 因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

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

[访问权限] abstract class 类名 {

成员列表

}

public abstract class Shapes {

public abstract void draw();

}

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，

设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并

覆盖抽象方法，实现具体功能。

三.面向对象特征--多态

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

class Animal{ ……
}
class Cat extends Animal{ ……
}
class Dog extends Animal { ……
}
Animal c = new Cat() //Animal 的引用指向Cat的对象
Animal d = new Dog() //Animal 的引用指向Dog的对象


//向上转型
class Animal{
void eat(){ }
}
class Cat extends Animal{
void eat() {
System.out.println("狗吃骨头");
}
}………
Animal x=new Cat() //向上造型，Cat对象提升到Animal对象
x.eat() //在编译奇迹只能调用父类中定义的方法, 如果子类重写了父类方法,那么运行时
调用子类重写的方法



//向下转型
class Animal{
void eat(){ }
}
class Cat extendsAnimal{
void look() {
System.out.println("看家");
}
} ………
Animal x=new Cat()
x.look();//编译报错,Animal类型中没有look方法
Cat m=(Cat)x; //需要向下转型,转为Cat类型
m.eat() ;
m.look();//子父类中的方法都可以使用

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

class Animal{
void eat() { }
}
class Cat extends Animal{
void eat() { }
}
class Dog extends Animal{
void eat(){ }
}
//方法的形参数类型是父类类型，而传递的实际参数可以是任意子类的对象
method(Animal animal){
animal .eat();
}

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

class Animal{
void show() {
System.out.println(“Anmial");
}
}
class Cat extends Animal{
void show() {
System.out.println(“cat");
}
}……. Animal x = new Cat()
x.show() //调用的是子类中的方法

简单的说：编译看左边，运行看右边。