JAVA part 7:面向对象

1218-马同学

发表文章数:15

热门标签

,
首页 » Java » 正文

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 part 7:面向对象

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();
从父到子,父类引用转为子类对象

JAVA part 7:面向对象

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

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

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

支付宝扫一扫打赏

微信扫一扫打赏

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

登录

忘记密码 ?

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

Q Q 登 录
微 博 登 录