大数据<javaSE + Linux精英实训班>_day_09

1：面向对象->继承

        描述事物之间的所属关系。使用种事物之间形成一种关系体系。
        在java中类的继承是指在现有类的基础上构建一个新的类，构建出来的新类我们称作子类，
        现有的类称作为父类。
        子类会自动拥有父类所有的可继承的属性和方法。

package com.itstar.demo01;
/*
 * 定义员工类
 *     属性和方法：
 *         成员变量    姓名
 *         成员方法    工作
 */
public class Emplpyee {
    String name;

    public void work() {
        System.out.println("员工在工作");
    }
}

package com.itstar.demo01;
/*
 * 定义研发部：
 *         属于员工中的一种
 *         研发共工继承研发类
 *
 * 关键字:extends
 *         子类Develop  父类Emplpyee
 * 子类自动拥有父类中可以继承的属性和方法
 *
 */
public class Develop extends Emplpyee{
    // 子类中定义了方法
    public void print() {
        // 打印的是父类的成员变量
        System.err.println(name);
    }
}

package com.itstar.demo01;
/*
 * 定义维护运维类
 *         属于员工的一种，继承员工类
 */
public class YunWei extends Emplpyee{
    public void weihu() {
        System.out.println(name);
    }
}

package com.itstar.demo01;

public class Test {
    public static void main(String[] args) {
        // 创建研发员工类的对象
        Develop d = new Develop();
        d.name = "裂缝";
        d.work();

        // 创建维护类对象
        YunWei y = new YunWei();
        y.name = "收嗯";
        y.weihu();
        y.work();

    }
}

2：面向对象->继承好处

        1、继承的出现提升了代码的复用性，提高软件开发效率。
        2、继承的出现让我们类与类之间产生了关系(继承关系)，提供了多态的前提。继承和多态是密不可分的
            的关系。
        3、父类中的属性和方法子类可以直接用，或者创建对象也可以用。
        

package com.itstar.demo02;

public class fu {
    int a = 1;
}

package com.itstar.demo02;

public class Zi extends fu{
    int a = 3;

    // 创建方法
    public void show() {
        int a = 4;
        System.out.println(a);
        // this可以用成员变量
        //System.out.println(this.a);

        // 调用的既不是成员变量也不是方法当中的变量，而是父类当中的变量
        System.out.println(super.a);
    }
}

package com.itstar.demo02;

public class Test {
    public static void main(String[] args) {
        // 创建对象
        Zi z = new Zi();

        int i = z.a;
        System.out.println(i);

        // 子类自己有的自然调用自己的，没有的调用父类的
        // 方法的就近原则，不是覆盖
        z.show();
    }
}

例子：

package com.itstar.demo03;

public class Fu {
    public void show() {
        System.out.println("父类中的show方法");
    }
}

package com.itstar.demo03;

public class Zi extends Fu{
    public void show() {
        System.out.println("子类的重写show方法");
    }

    public void show2() {
        System.out.println("子类中的show2方法");
    }
}

package com.itstar.demo03;

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        // 子类中没有show方法，自然去父类当中找
        z.show();
        z.show2();
    }
}

代码例子：

package com.itstar.demo04;
/*
 * 定义手机功能
 *         功能：打电话、发短信、微信
 */
public class Phone {
    public void Call() {
        System.out.println("手机在打电话");
    }

    public void sendMessage() {
        System.out.println("手机在发短信");
    }

    public void weChat() {
        System.out.println("手机在微信");
    }
}

package com.itstar.demo04;
/*
 * 方法覆盖的注意事项：
 *         子类方法覆盖父类方法，必须保证权限要大于等于父类的权限
 *         子类重写父类的方法，保证子类的权限要大于等于父类的权限
 * java中有4大权限：依次减小
 *         public：公有
 *         protected：受保护的
 *         default：默认(特别，不写)权限
 *         private：私有的
 */
public class AndroindPhone extends Phone{
    public void weChat() {
        super.weChat();
        System.out.println("跳一跳");
        System.out.println("脑强王者");
    }
}

package com.itstar.demo04;

public class Test {
    public static void main(String[] args) {
        // 创建对象
        Phone p = new Phone();

        p.Call();
        p.sendMessage();
        p.weChat();

        AndroindPhone ap = new AndroindPhone();
        ap.weChat();
    }
}

package com.itstar.demo05;
/*
 * 定义类，开发工程师类
 *         ee工程师：工作
 *         安卓工程师：工作
 */
public abstract class Develop {
    public abstract void work();
}

package com.itstar.demo05;

public class JavaEE extends Develop{
    // 重写父类的抽象方法
    public void work() {
        System.out.println("JAVAEE工程师正在开发后台管理系统");
    }
}

package com.itstar.demo05;

public class Android extends Develop{
    public void work() {
        System.out.println("Andoid工程师正在开发手机软件");
    }
}

package com.itstar.demo05;

public class Test {
    public static void main(String[] args) {
        // 父类为抽象类  所以没有办法实例化
        JavaEE j = new JavaEE();
        j.work();

        Android a = new Android();
        a.work();
    }
}

package com.itstar.demo06;

public abstract class Animal {
    public void sleep() {
        System.out.println("动物在睡觉");
    }
    //private abstract void show();不可以，原因，本来抽象类的存在就是让子类去重写抽象类方法的
    public abstract void show();
}

package com.itstar.demo06;

public class Cat extends Animal{
    public void show() {
        System.out.println("小猫正在睡觉");
    }
}

package com.itstar.demo06;

public class Test {
    public static void main(String[] args) {
        Cat  c = new Cat();
        c.sleep();
        c.show();
    }
}

package com.itstar.demo07;
/*
 * 员工类
 *
 */
public abstract class Employee {
    private String name;
    private String id;

    public abstract void work();

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

package com.itstar.demo07;
/*
 * 研发部
 */
public abstract class Develop extends Employee{

}

package com.itstar.demo07;

public class JavaEE extends Develop{

    public void work() {
        System.out.println("JavaEE在开发淘宝" + super.getId() + "...." + super.getName());
    }

}

package com.itstar.demo07;

public abstract class YunWei extends Employee{

}

package com.itstar.demo07;

public class NetWork extends YunWei{
    public void work() {
        System.out.println("网络工程师在装网络" + super.getId() + "..." + super.getName());
    }
}

package com.itstar.demo07;

public class Test {
    public static void main(String[] args) {
        JavaEE ee = new JavaEE();
        NetWork n = new NetWork();

        ee.setId("研发1号小弟");
        ee.setName("小店");

        n.setId("运维2号小弟");
        n.setName("农二");

        ee.work();
        n.work();
    }
}

原文地址：https://www.cnblogs.com/guijin/p/8645824.html