JAVA part 7：面向对象

面向对象

继承

1.多个类中存在相同属性和行为时，将这额内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
2.通过extend关键字可以实现类与类的继承
3.单独的这个类成为父类，基类或者超类；这多个类可以称为子类或者派生类。
4.有了继承以后，我们定义了一个类的时候，可以再一个已经存在的类的基础上，还可以定义自己的新成员。

public class 子类名 extends 父类名{}

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

继承的弊端：
1.让类与类之间产生了关系，也就让类的耦合性增强了

开发原则：高内聚，低耦合
内聚：就是自己完成某件事情的能力
耦合：类与类的关系

//GrandFather类
package Day_7;
public class GrandFather{
    public void grandFatherSay(){
        System.out.println("爷爷都是从孙子熬过来的")
    }
}


//Father类
package Day_7;
public class Father extends GrandFather{
    public void fatherSay(){
        System.out.println("爷爷都是从孙子熬过来的")
    }
}


//son类
package Day_7;
public class Son extends Father{
    public static void main(String[] args) {
        Son s = new Son();
        s.fatherSay();
        s.grandFatherSay();
    }
}

tips:
JAVA中类只支持单继承，不支持多继承
但JAVA中的类支持多层继承

JAVA继承中成员变量特点：
1.成员变量名称不一样，使用的时候非常简单
2.成员变量名称一样的情况下：
在子类方法中访问变量采用就近原则：
①在方法的局部变量范围内找，如果有就使用
②在子类的成员范围找，如果有就使用
③在弗雷的成员范围找，如果有就是用
④如果还找不到就报错

super关键字

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

super和this的用法：
①访问成员变量：
this.成员变量
super.成员变量
②访问构造方法：
this(…)
super(…)
③访问成员方法：
this.成员方法()
super.成员方法()

package Day_7;
public class test2 {
    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继承中的构造方法

特点：
1.子类构造方法执行前都会先执行父类无参构造方法
因为在子类继承父类，会继承父类的非私有成员
而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，子类就不能使用这些数据，所以在子类初始化之前，一定要先完成父类数据的初始化

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

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


//Son 类
package Day_7;
public class Son {
    public Son() {
        super();
        System.out.println("Son无参构造方法");
    }
    public Son(String name){
        super();
        System.out.println("Son带参构造方法");
        System.out.println(name);
    }
}


// 使用
package Day_7;
public class ExtendsTest {
    public static void main(String[] ages){
        Son s = new Son;//输出Father无参构造和Son无参构造
        System.out.println("-----------------");
        Son s2 = new Son("林青霞");//输出Father无参构造和Son带参构造和林青霞
    }
}

tips：
如果父类没有无参构造可以在父类中添加一个无参构造方法（推荐）
或通过使用super去访问父类的带参构造，即将super();换成super("林青霞”)；
输出如下图

JAVA继承中的成员方法

特点：
1.在子类中方法和父类中方法的声明不一样，可以直接观察
2.子类方法和父类方法的声明一样，执行子类中的方法

通过子类对象调用方法：
1.在子类中找，有就用
2.在父类中找，有就用
3.如果没有就报错

// Father 类
package Day_7;
public class Father {
    public void show() {
        System.out.println("Father  show");
    }
}


//Son 类
package Day_7;
public class Son extends Father{
    public void method() {
        System.out.println("Son method");
    }
    public void show(){
        System.out.println("Son show");
    }
}


// 使用
package Day_7;
public class ExtendsTest {
    public static void main(String[] ages){
        Son s = new Son;
        s.method();//输出 Son method
        s.show();//输出 Son show
    }
}

方法重写

即子类中出现了和父类一样的方法声明的情况

方法重写应用：
当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就需要考虑方法重写super();
这样既保证了父亲的功能，还添加了子类的特有内容

@Override
是提示该方法为重写父类的注解

方法重写的注意事项：
1.父类私有方法不能被重写
2.子类重写父类方法，访问权限不能比父类更低
public > 默认修饰符(void) > private

多态

同一个对象，在不同时刻体现出不同状态

举例：
猫：猫是猫，也是动物
水：固体，液体，气体

多态前提：
1.有继承关系
2.有方法重写
有父类引用指向子类对象
Fu f = new Zi();

多态中成员的访问特点：
A.成员变量
编译看左边，执行看左边
2.成员方法
编译看左边，执行看右边

//Animal 父类
package Day_7;
public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("吃东西");
    }
}

//Cat 子类
package Day_7;
public class Cat extends Animal {
    public int age = 20;
    public int weigth = 10;

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

// 使用
package Day_7;
public class DuoTaiDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();
        System.out.println(a.age);
        
        a.eat();
    }
}

多态的好处：
提高了程序的扩展性
具体体现在：定义方法的时候，使用父类型作为参数，将来使用的时候，使用具体的子类型参与操作
多态的弊端：
不能使用子类的特有方法

多态的转型：
1.向上转型： Fu f = new Zi();
从子到父，父类引用指向子类对象
2.向下转型： ZI z = new Fu();
从父到子，父类引用转为子类对象

分享到：

赞(0) 打赏