Java基础篇之面向对象（2）

最新推荐文章于 2021-02-26 15:27:20 发布

big coke

最新推荐文章于 2021-02-26 15:27:20 发布

阅读量151

点赞数

本文链接：https://blog.csdn.net/weixin_43657820/article/details/105136504

版权

继承：

导出问题：

多个类中存在多个相同属性和行为

public class Student {


    private String name;
    private int age;
    public Student() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
//getXxx() setXxx()
    public void study(){
        System.out.println("学生要好好学习");
    }

}

public class Teacher {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Teacher() {
    }
    //getXxx() setXxx()

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void learn() {
        System.out.println("老师要好好讲课");
    }
}

上述两类中存在多个相同属性和行为，将这些内容提取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

如何实现类与类的继承：

通过extends关键字即可：

public class 子类名 extends 父类名{}

单独的这个类称为父类，基类或者超类，这多个类可以称为子类或者派生类

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。

继承的好处与弊端：

public class Person {
private String  name;
private int age;
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }

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

public class Teacher extends Person {
public void learn(){
    System.out.println("老师要好好教书");
}
}

继承的好处：

A：提高了代码的复用性

B：提高了代码的维护性

C：让类与类之间产生了关系，是多态的前提

继承的弊端：

让类与类之间产生了关系，也就让类的耦合性增强了。

开发原则：高内聚，低耦合。

内聚：就是自己完成某件事件的能力

耦合：类与类的关系

java中继承的特点：

Java中类只支持单继承，不支持多继承

但Java支持多层继承

代码如下：

public class Grandfather {
public void grdsay(){
    System.out.println("爷爷都是从孙子熬过来的");
}
}

public class Father extends Grandfather{
public void fatsay(){
    System.out.println("爸爸都是从儿子熬过来的");
}
}

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

输出结果：

爸爸都是从儿子熬过来的
爷爷都是从孙子熬过来的

Java继承中成员变量的特点：

A：成员变量名称不一样，使用的时候非常简单

B：成员变量一样的情况

在子类方法中访问变量：

A：在方法的局部范围找，如果有就使用

B：在子类的成员范围找，如果有就使用

C：在父类的成员范围找，如果有就使用

D：如果还找不到，就报错

就近原则

public class Father {
    public int age = 45;//为了演示内容方便，此处用public修饰词
}

public class Son extends Father{
    public int height = 170;
    public int age = 20;
    public void show(){
        System.out.println(height);
        System.out.println(age);
    }
    public void printage(){
        int age = 10;
        System.out.println(age);
    }
}

public class Extend_Test {
    public static void main(String[] args) {
        Son s = new Son();
        //s.show();
        s.printage();
    }
}

输出结果：

10

super关键字：

super和this的用法很像：

this：代表本类对象的引用

super：代表父类的存储空间（可以理解为代表父类对象的引用）

用法：

访问成员变量：

this.成员变量

super.成员变量

访问构造方法：

this.（...）

super.（...）

访问成员方法：

this.成员方法（）

super.成员方法（）

Java继承中构造方法的特点：

A：子类构造方法执行前都会先执行父类无参构造

B：为什么：

因为子类继承父类，会继承父类的非私有成员

而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化

子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化

注意：在子类的构造方法中，默认第一行有一条语句super（）

public class Father {
    public Father(){
        System.out.println("father无参构造方法");
    }
    public Father(String name){
        System.out.println("father带参构造方法");
        System.out.println(name);
    }
}

public class Son extends Father{
    public Son(){
        System.out.println("Son无参构造方法");
    }
    public Son(String name){
        System.out.println("Son带参构造方法");
        System.out.println(name);
    }
}

public class Extend_Test {
    public static void main(String[] args) {
        Son s = new Son();
        System.out.println("------");
        Son s2 = new Son("林青霞");

    }
}

输出：

father无参构造方法
Son无参构造方法
------
father无参构造方法
Son带参构造方法
林青霞

假如父类中没有无参构造方法，怎么办：

A：在父类中添加一个无参构造方法。

B：可以通过super去访问父类的带参构造方法

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

public class Father {
    public Father(String name){
        System.out.println("father带参构造方法");
        System.out.println(name);
    }
}

public class Son extends Father{
    public Son(){
        super("林青霞");
        System.out.println("Son无参构造方法");
    }
    public Son(String name){
        super("篮球场");
        System.out.println("Son带参构造方法");
        System.out.println(name);
    }
}

public class Extend_Test {
    public static void main(String[] args) {
        Son s = new Son();
        System.out.println("------");
        Son s2 = new Son("林青霞");

    }
}

输出结果：

father带参构造方法
林青霞
Son无参构造方法
------
father带参构造方法
篮球场
Son带参构造方法
林青霞

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

A：子类中方法和父类中方法的声明不同，很好访问

B：子类中方法和父类中方法的声明一样，执行的是子类中的方法

通过子类对象调用方法：

A：在子类中找，有就使用

B：在父类中找，有就使用

C：如果没有就报错

方法重写：

当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写

这样既保证了父类的功能，还添加了子类的新功能。

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

public class New_Phone extends Phone{
public void call(String name){
    System.out.println("开启视频功能");
    //System.out.println("给"+name+"打电话");
    super.call(name);
}
}

public class Phone_Test {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("林青霞");
        New_Phone np = new New_Phone();
        np.call("林青霞");
    }
}

输出结果：

给林青霞打电话
开启视频功能
给林青霞打电话

方法重写的注意事项：

@override 这是一个注解表示方法重写

注意：

A：父类私有的方法不能重写

B：子类访问父类方法时，访问权限不能更低

子类重写父类方法时，建议访问权限一模一样

低（private ------默认修饰符------public)高

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

public class New_Phone extends Phone {
    @Override
    public void call(String name) {
        System.out.println("开启视频功能");
        //System.out.println("给"+name+"打电话");
    super.call(name);
    }
}

public class Phone_Test {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("林青霞");
        New_Phone np = new New_Phone();
        np.call("林青霞");
    }
}

输出：

给林青霞打电话
开启视频功能
给林青霞打电话

继承练习：

学生和老师案例：

思路：

学生类：

成员变量：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 void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public Person(){}
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

}

public class Student extends Person {
    public Student() {}
    public Student(String name,int age) {
        super(name,age);
    }
public void study(){
    System.out.println("学生要好好学习");
}
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s.getName()+"...."+s.getAge());
        s.study();
        Student s2 = new Student("林青霞",30);
        System.out.println(s.getName()+"...."+s.getAge());
        s2.study();
    }
}

输出结果：

林青霞....30
学生要好好学习
林青霞....30
学生要好好学习

多态：

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

Java多态的前提：

A：有继承关系

B：有方法重写

C：有父类引用指向子类对象

public class Animal {
public void eat(){
    System.out.println("吃东西");
}
}

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

public class DuoTaiDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
    }
}

多态中成员访问特点：

A：成员变量：

编译看左边，执行看右边。

B：成员方法

编译看左边，执行看右边

为什么成员变量和成员方法访问不一样

因为成员方法有重写，而变量没有。

public class Animal {
    public int age = 40;

    public void eat() {
        System.out.println("吃东西");
    }
}

 public class Cat extends Animal {
        public int age = 10;
        public int weight = 20;
        public void eat(){
            System.out.println("猫吃鱼");
        }
         public void playgame(){
             System.out.println("猫捉迷藏");
            }

    }

public class DuoTaiDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        System.out.println(a.age);
        //System.out.println(a.weight);
        a.eat();
        //a.playgame();
    }
}

输出结果：

40
猫吃鱼

多态的好处与弊端：

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

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

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

多态中的转型问题：

向上转型：

从子到父

父类引用指向子类对象

向下转型：

从父到子

父类引用转为子类对象

public class DuoTaiDemo {
    public static void main(String[] args) {
        Animal a = new Cat();//向上转型
        a.eat();
        //System.out.println(a.weight);
//        a.eat();
        //a.playgame();
        //多态的弊端：无法访问子类特有方法
        //现在想要使用子类特有方法
//        Cat c = new Cat();
//        c.playgame();
        //现在的代码虽然可以访问子类特有的功能，但不合理
        //因为内存中有两个猫类的对象
        //这时候我们要想办法把多态中的猫对象还原
        Cat c = (Cat)a;
        c.eat();
        c.playgame();
    }
}

输出结果：

猫吃鱼
猫吃鱼
猫捉迷藏

多态转型内存图解：

多态练习：

public class Animal {
    public int age = 40;

    public void eat() {
        System.out.println("吃东西");
    }
}

    public class Cat extends Animal {
//        public int age = 10;
//        public int weight = 20;
        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 DuoTaiDemo {
    public static void main(String[] args) {
        Animal a = new Cat();//向上转型
        a.eat();
        Cat c = (Cat)a;
        c.eat();
        c.playgame();//向下转型
        a = new Dog();
        a.eat();
        Dog d  = (Dog)a;
        d.eat();
        d.lookdoor();
    }
}

输出结果：

猫吃鱼
猫吃鱼
猫捉迷藏
狗吃骨头
狗吃骨头
狗看门

big coke

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础篇之面向对象（2）

目录继承：如何实现类与类的继承：继承的好处与弊端：继承的好处：继承的弊端：java中继承的特点：Java继承中成员变量的特点：super关键字：Java继承中构造方法的特点：Java继承中成员方法的访问特点：方法重写：方法重写的注意事项：继承练习：多态：多态中成员访问特点：多态的好处与弊端：多态中的转型问题：多态转型内存...
复制链接

扫一扫