Java面向对象2

1269-郑同学

发表文章数:16

热门标签

首页 » Java » 正文

面向对象2

继承

继承概述

  • 多个类中存在相同属性和行为时,将这些内容抽取到单独的一个类中,那么多个类就无需再定义这些属性和行为,只要继承那个类即可。
  • 通过extends关键字就可以实现类与类的继承
    public class 子类名 extends 父类名 { }
  • 单独的这个类被称为父类,基类或者超类,多个类可以称为子类或者派生类
  • 有了继承以后,我们定义一个类时,可以在一个已经存在的类的基础上,还可以定义自己的新成员。

继承的格式

		public class 子类名 extends 父类名 {}

继承的好处

  1. 提高了代码的复用性
  2. 提高了代码的维护性
  3. 让类与类之间产生了关系,是多态的前提

继承的弊端:让类与类之间产生了关系,也就让类的耦合性增强了

开发原则:高内聚,低耦合。
内聚:自己完成某件事情的能力
耦合:类与类的关系

Java继承的特点

  • Java中类只支持单继承,不支持多继承。
  • Java中类支持多层继承
public class GrandFather {
    public void grandFatherSay() {
        System.out.println("爷爷都是从孙子熬过来的");
    }
}
public class Father extends GrandFather {
    public void fatherSay() {
        System.out.println("爸爸都是从儿子走过来的");
    }
}
/*
public class Son extends GrandFather {
    public static void main(String[] args) {
        Son s = new Son();
        s.grandFatherSay();
    }
}
 */

/*
public class Son extends Father {
    public static void main(String[] args) {
        Son s = new Son();
        s.fatherSay();
    }
}
 */

//Java中类只支持单继承,不支持多继承
/*
public class Son extends Father, GrandFather {
    public static void main(String[] args) {
        Son s = new Son();
        s.fatherSay();
    }
}
 */

//Java中类支持多层继承
public class Son extends Father {
    public static void main(String[] args) {
        Son s = new Son();
        s.fatherSay();
        s.grandFatherSay();
    }
}

Java继承中成员变量的特点

  1. 成员变量名称不一样,使用的时候非常简单
  2. 成员变量名称一样时,就近原则
    在子类方法中访问变量:
    a. 在方法的局部范围找,如果有就使用
    b. 在子类的成员范围找,如果有就使用
    c. 在父类的成员范围找,如果有就使用
    d. 如果还找不到,就报错

super关键字

super和this的用法相似:
this:代表本类对象的引用
super:代表父类的存储空间(可以理解为代表父类对象的引用)

用法:

  • 访问成员变量
    this.成员变量
    super.成员变量
  • 访问构造方法
    this(…)
    super(…)
  • 访问成员方法
    this.成员方法()
    super.成员方法()
public class Son extends Father {
    public int age = 20;

    public void printAge() {
        int age = 10;
        System.out.println(age);
        //访问成员范围的age
        System.out.println(this.age);
        //访问父类成员范围的age
        System.out.println(super.age);
    }
}

Java继承中构造方法的特点

Java继承中构造方法的访问特点:

  • 子类构造方法执行前,都会先执行父类无参构造方法
    子类继承父类,会继承父类的非私有成员
    而子类在初始化的时候,可能会使用父类的数据,如果父类数据没有先初始化,子类就不能使用这些数据,所以在子类初始化之前,一定要先完成父类数据的初始化
  • 注意:在子类的构造方法中,默认第一行有一条语句:super();

问题:假如父类中没有无参构造方法?

  1. 在父类中添加一个无参构造方法
  2. 可以通过super去访问父类的带参构造方法

建议使用第一种解决方案,其实就是要求我们写代码的时候,每次都手动给出无参构造方法。

Java继承中成员方法的特点

Java继承中成员方法的访问特点:

  • 如果子类中方法和父类中方法的声明不一样,很简单
  • 如果子类中方法和父类中方法的声明一样,执行的是子类中的方法

通过子类对象调用方法:

  1. 在子类中找,有就使用
  2. 在父类中找,有就使用
  3. 如果没有就报错

方法重写

方法重写:子类中出现了和父类一模一样的方法声明的情况
案例:

public class Phone {
    public void call(String name) {
        System.out.println("给"+name+"打电话");
    }
}

public class NewPhone extends Phone {
    public void call(String name) {
        System.out.println("开启视频功能");
        //System.out.println("给"+name+"打电话");
        super.call(name);
    }
}
public class PhoneTest {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("林青霞");

        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}

方法重写的应用:
当子类需要父类的功能,而功能主体子类又有自己的特有内容的时候,就考虑使用方法重写,这样既保证父类的功能,还添加了子类的特有内容。

@Override:注解,标记一个方法,表明该方法是重写父类的方法

方法重写的注意事项:

  1. 父类私有的方法不能被重写
  2. 子类重写父类方法时,访问权限不能更低
    子类重写父类方法时,建议访问权限一模一样
public class Father {
    /*
    public void show() {
        System.out.println("show father");
    }
     */

    /*
    private void show() {
        System.out.println("show father");
    }
    //父类私有的方法不能被重写
     */

    //默认修饰符
    //private -- 默认修饰符 -- public
    void show() {
        System.out.println("show father");
    }
}
public class Son extends Father {
    @Override
    public void show() {
        System.out.println("show son");
    }

    /*
    @Override
    public void method() {
        System.out.println("method son");
    }
    //报错,这不是重写父类的方法
     */
}

练习

学生和老师的案例

分析

学生类:
	成员变量:name,age
	构造方法:无参,带参
	成员方法:getXxx(),setXxx(),study()
老师类:
	成员变量:name,age
	构造方法:无参,带参
	成员方法:getXxx(),setXxx(),teach()
我们发现这两个类中相同代码比较多,所以提取出一个父类
人类:
	成员变量:name,age
	构造方法:无参,带参
	成员方法:getXxx(),setXxx()
学生类:
	继承人类
	study()
老师类
	继承人类
	teach()
public class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 class Student extends Person {

    public Student(String name, int age) {
        super(name, age);
    }

    public Student() {}

    public void study() {
        System.out.println("学生要好好学习");
    }
}
public class Teacher extends Person {

    public Teacher() {}

    public Teacher(String name, int age) {
        super(name, age);
    }

    public void teach() {
        System.out.println("老师要好好上课");
    }
}
public class ExtendsTest {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        System.out.println(s1.getName()+"---"+s1.getAge());
        s1.study();

        Student s2 = new Student("林青霞",30);
        System.out.println(s2.getName()+"---"+s2.getAge());

        Teacher t1 = new Teacher();
        t1.setName("林青霞");
        t1.setAge(30);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.teach();

        Teacher t2 = new Teacher("林青霞",30);
        System.out.println(t2.getName()+"---"+t2.getAge());
    }
}

多态

多态:同一个对象,在不同时刻体现出来的不同状态

举例:
猫:猫是猫,猫是动物
水:液体,固体,气体

Java中多态的前提:

  • 有继承关系
  • 有方法重写
  • 有父类引用指向子类对象
Fu f = new Fu();
Zi z = new Zi();

Fu f = new Zi();

案例:

public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}
public class Cat extends Animal{
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class duotai {
    public static void main(String[] args) {
        Animal a = new Cat();
    }
}

多态中成员访问特点

多态中成员访问特点:

  • 成员变量
    编译看左边,执行看左边
  • 成员方法
    编译看左边,执行看右边

成员变量和成员方法的访问不一样:成员方法有重写,成员变量没有。

public class Animal {
    public int age = 40;

    public void eat() {
        System.out.println("吃东西");
    }
}
public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;

    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
public class Test {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();
        System.out.println(a.age); //40
        //System.out.println(a.weight); //报错

        a.eat(); //猫吃鱼
        //a.playGame(); //报错
    }
}

多态的好处和弊端

多态的好处:提高了程序的扩展性

具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作

多态的弊端:不能使用子类的特有功能

public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}
public class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}
public class Pig extends Animal {
    public void eat() {
        System.out.println("猪吃白菜");
    }
}
public class AnimalOperator {
    /*
    public void useAnimal(Cat c) {
        c.eat();
    }

    public void useAnimal(Dog d) {
        d.eat();
    }

     */

    public void useAnimal(Animal a) {
        a.eat();
        //a.lookDoor(); //报错
    }
}
public class Demo {
    public static void main(String[] args) {
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);

        Pig p = new Pig();
        ao.useAnimal(p);
    }
}

多态中的转型问题

多态的转型:

  • 向上转型
    从子到父
    父类引用指向子类对象
  • 向下转型
    从父到子
    父类引用转为子类对象
public class Demo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat(); //向上转型
        a.eat();

        //a.playGame();
        //多态无法访问子类特有方法
        //创建子类对象使用子类特有方法
        /*
        Cat c = new Cat();
        c.playGame();
        //现在的代码虽然可以访问子类特有功能,但是不合理
        //因为我们发现内存中有两个猫类对象
         */
        //我们想办法把多态中的猫对象还原
        //这时就要使用多态中的转型
        //父类引用转为子类对象
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

类型转换异常:向上转型和向下转型应该匹配上,如果向下转型出现ClassCastException类型转换异常,说明是不匹配的。

练习

动物:
	eat()
猫:
	eat()
	playGame()
狗:
	eat()
	lookDoor()
public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}
public class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
public class Dog extends Animal{
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}
public class duotaiTest {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();

        Cat c = (Cat) a;
        c.eat();
        c.playGame();

        Animal b = new Dog();
        b.eat();

        Dog d = (Dog) b;
        d.eat();
        d.lookDoor();
    }
}

总结:如果想使用子类的特有功能,必须使用向下转型,且要保证当前内存中是能够转成具体的子类类型的。

标签:

拜师教育学员文章:作者:1269-郑同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《Java面向对象2》 发布于2020-09-08

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录