JAVA SE — Day 10

最新推荐文章于 2020-09-17 13:47:32 发布

娇小妖

最新推荐文章于 2020-09-17 13:47:32 发布

阅读量338

点赞数

分类专栏： java-se-基础文章标签： java se

本文链接：https://blog.csdn.net/yanqing_happy/article/details/78502165

版权

java-se-基础专栏收录该内容

22 篇文章 1 订阅

订阅专栏

第1章继承
1.1 继承的概念
1.2 继承的格式和作用
1.3 继承的优势及注意事项
1.4 继承-子父类中成员变量的特点
1.5 继承-子父类中成员方法的特点
1.6 方法重写的注意事项
第2章抽象类
2.1 抽象类的产生
2.2 抽象方法的定义& 使用方式
2.3 抽象类的特点
2.4 抽象类的细节问题
第3章综合案例员工案例
3.1 案例介绍
3.2 案例分析
3.3 代码实现
第4章总结

第1章继承

1.1 继承的概念

1）继承的概念
●继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系
●在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类
2）继承关系的子类特点
●子类会自动拥有父类所有非private修饰的属性和方法

1.2 继承的格式和作用

1）继承的格式
class 子类 extends 父类 {}
2）雇员(Employee)与研发部员工(Developer)案例:
父类：

/*
 * 定义员工类
 * 属性和方法
 * 属性成员变量：姓名
 * 成员方法：工作
 */
public class Employee {
      String  name;

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

子类：

*
 * 定义研发部员工，属于员工的一种
 *     研发员工 继承 员工类
 *     
 *     关键字 ： extends
 *     子类是Develop，父类是Employee，
 *     子类拥有父类中非私有的属性和方法
 */
public class Develop extends Employee{
     public  void print() {
         System.out.println(name);
     }

}

测试类：

public class Test {
    public static void main(String[] args) {
        //创建研发员工类的对象
        Develop d = new Develop();
        //使用子类的

        d.name = "张三";
        d.print();
        d.work();

    }
}

1.3 继承的优势及注意事项

1.优劣势：
1）继承的出现提高了代码的复用性，提高软件开发效率。
2）继承的出现让类与类之间产生了关系，提供了多态的前提。
3）劣势就是类之间紧密型太强，如果父类删除，子类也就无法使用了。
2.注意事项
1）在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

这里写图片描述
2）多个类可以继承一个父类，例如下面这种情况是允许的(就像你爹可以多个儿子,但是这些儿子都只有一个爹)

3）在Java中，多层继承是可以的，类似可以出现孙子类。

这里写图片描述

3.继承的体系

这里写图片描述

1.4 继承-子父类中成员变量的特点

①子类的对象调用成员变量的时候,子类自己有,使用子类的。

这里写图片描述

② 子类的对象调用成员变量的时候,子类自己没有,使用父类的。

这里写图片描述

③子类中成员变量和局部变量重名时：方法的就近访问原则。
并非是覆盖，因为覆盖必须满足两个条件，一是重名，二是在相同内存下（也可以理解为同文件夹）。而成员变量跟着对象在堆内存里存储，局部变量跟着方法进入栈内存，不同内存下无法覆盖。所以这里体现了方法的就近访问。

这里写图片描述

④方法内有同名变量时，想输出子类中的成员变量时：使用this.子类成员变量

这里写图片描述

⑤当子父类中出现了同名成员变量，想输出父类的成员变量时：使用super.父类成员变量

这里写图片描述

1.5 继承-子父类中成员方法的特性

①子类的对象调用方法的时候,子类自己有,使用子类,子类自己没有，调用父类的
这里写图片描述

这里写图片描述

②子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖
这里写图片描述

1.6 方法重写

1）方法覆盖的需求
①案例:
比如手机，当描述一个手机时，它具有发短信，打电话，显示来电号码功能。
随着发展，需要来电时可以显示对方头像，这时可以重新定义一个类描述智能手机，并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能，在其中增加显示姓名和头像。
②分析:我们不改装(破坏)原来的手机,而是再买一个新的智能手机,不但有原有的功能,而且还有特有功能。

 手机类
   属性(成员变量):无
   行为(成员方法):
                发短信
                打电话
                来电显示:显示来电号码

  智能手机类:
    属性(成员变量):无
    行为(成员方法):
                 发短信
                 打电话
                 来电显示:显示来电号码,显示姓名和头像

手机类和智能手机类有共性内容:  发短信 打电话 显示来电号码

2）方法覆盖的手机案例实现
手机类：

/*
 * 定义手机类
 * 功能：打电话，发短信，显示来电号码
 */
public class Phone {
      public  void  call () {
          System.out.println("手机在打电话");
      }

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

      public  void  showNum () {
          System.out.println("显示手机号码");
      }

}

智能手机类：

/*
 * 定义智能手机类
 * 功能：打电话，发短信
 * 来电显示：号码，姓名，显示头像
 * 
 * 新的智能手机前两个功能没有变化，只有来电功能变化了
 * 新的智能手机继承原先手机的打电话和发短信功能
 * 但是，将原来的来电功能进行重写，添加显示头像功能
 * 
 */
public class AndroidPhone  extends Phone {
        public  void  showNum() {
            //父类中的方法showNum已经可以显示号码，子类直接用
            super.showNum();
            System.out.println("显示姓名");
            System.out.println("显示头像");
        }  
}

测试类：

public class Test {
      public static void main(String[] args) {


        AndroidPhone ap = new AndroidPhone ();
        ap.showNum();
        ap.call();
        ap.sendMessage();
    }
}

3）方法重写的注意事项
①权限:子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
public（公有）>default（不能写出来，表示默认）=protected（受保护）>private（私有）
方法定义:子类方法和要重写的父类的方法:方法的方法名和参数列表都要一样。
②关于方法的返回值:
如果是基本数据类型,子类的方法和重写的父类的方法返回值类型必须相同。
如果是引用数据类型,子类的方法和重写的父类的方法返回值类型可以相同或者子类方法的返回值类型是父类方法返回值类型的子类。
③重载与重写对比:

    重载:
        权限修饰符(public private 默认):无关
        方法名:重载的两个方法的方法名必须相同
        形参列表:
               形参类型的顺序不同
               形参的个数不同
               形参的类型不同
               三者至少满足一个
        返回值类型:
               重载与返回值类型无关


    重写:
        权限修饰符(public private 默认): 
          子类方法的权限>=父类的方法的权限
        方法名: 
          子类方法和父类方法必须相同
        形参列表: 
           子类方法和父类方法的形参列表必须相同
        返回值类型:
            基本数据类型:
                       必须相同
            引用数据类型:
                       子类方法的返回值类型和父类方法的返回值类型相同
           或者子类方法的返回值类型是父类方法的返回值类型的子类

第2章抽象类

2.1 抽象类的产生

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

2.2 抽象方法的定义& 抽象类的使用方式

①抽象方法定义的格式：
public abstract 返回值类型方法名(参数);


          public abstract class 类名 {

          }

②代码示例：
抽象类：

/*
 * 定义开发工程师类
 * EE开发工程师：工作
 * Android开发工程师：工作
 * 
 * 根据共性进行抽取，形成父类Develop
 * 定义方法：工作，具体做什么不知道
 * 
 * 抽象类，不能实例化，即不能new（不能创建对象）
 * 不能创建对象的原因：没有主体就没有办法调用方法，不能运行
 * 抽象类的使用：定义继承抽象类，将抽象方法重写，创建子类的对象即可
 * 
 */
public abstract  class Develop {
      //定义方法工作，但是具体内容说不清楚
      //没有主体方法，必须使用关键字abstract修饰
      //抽象的方法必须在抽象的类中，所以类也必须用abstract修饰
      public abstract void work();

}

子类JavaEE：

/*
 * 定义JavaEE的开发人员
 * 继承抽象Develop，重写抽象方法
 * 
 */
public class JavaEE extends Develop {
   //重写父类抽象方法
   //去掉abstract修饰符，加上方法主体
    public void work () {
        System.out.println("JavaEE工程师在开发B/S 软件");
    }
}

子类Android：

public class Android extends Develop  {
    //重写父类抽象方法
       //去掉abstract修饰符，加上方法主体
        public void work () {
            System.out.println(" Android工程师在开发手机软件");
        }
}

测试类：

/*
 * 测试抽象类
 *     创建子类对象，使用子类的对象调用方法
 * 
 */
public class Test {
       public static void main(String[] args) {
           JavaEE ee = new JavaEE();
           ee.work();
           Android an = new  Android();
           an.work();

    }
}

2.3 抽象类的特点

1）抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。

2）抽象类不可以直接创建对象，原因：调用抽象方法没有意义。只能通过创建子类，子类继承抽象类，重写抽象方法（去掉abstract修饰符，加上方法主体）用子类的对象调用方法。

3）只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。如果子类继承抽象类，只重写了其中一部分抽象方法，该子类还是一个抽象类，即仍然不能创建对象（不能new）。

这里写图片描述

2.4 抽象类的细节问题

1）抽象类一定是个父类？
是的，因为不断抽取而来的。

2）抽象类中是否可以不定义抽象方法?
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象。定义的方法（非抽象方法）可以直接让子类去使用。
例如：
父类（抽象类）：

        /*
         *   抽象类,可以没有抽象方法,可以定义带有方法体的方法
         *   让子类继承后,可以直接使用
         */
        public  abstract class Animal {
             public void sleep(){
                 System.out.println("动物睡觉");
             }

        }

子类：

        public class Cat extends Animal{

        }

测试类：


        public class Test {
            public static void main(String[] args) {
                //Cat c = new Cat();
                new Cat().sleep();//不让该类创建对象,方法可以直接让子类去使用
            }
        }

3）抽象关键字abstract不可以和哪些关键字共存？

① private：私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法,而private修饰子类根本无法得到父类这个方法。互相矛盾。
这里写图片描述
② final，暂时不关注，后面学
③ static，暂时不关注，后面学

第3章综合案例员工案例

3.1 案例介绍

1）需求描述:
某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部员工、维护部员工）。
研发部根据所需研发的内容不同，又分为JavaEE工程师、Android工程师；
维护部根据所需维护的内容不同，又分为网络维护工程师、硬件维护工程师。
公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。
即：

 JavaEE工程师：员工号为xxx的 xxx员工，正在研发淘宝网站
 Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
 网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通
 硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机

2）继承体系:
这里写图片描述

3.2 案例分析

根据员工信息的描述，确定每个员工都有员工编号、姓名、要进行工作。
则，把这些共同的属性与功能抽取到父类中（员工类）。而JavaEE工程师和 Android工程师同属于研发部，则研发部员工类既是员工类的子类又是JavaEE类和 Android类的父类。同理维护部员工类既是员工类的子类又是网络维护类和硬件维护类的父类。

（注意在本例需求中没有体现研发部类和维护部类的作用，但是如果有需求加上：研发部的发两个月薪年终奖，维护部发一个月薪年终奖，则能看出这两个子类的作用了）

3.3 代码实现

1）父类
员工类：

/*
 * 定义员工类
 * 内容都是从子类抽取的共性
 * 属性：姓名，工号
 * 方法：工作
 * 
 */
public abstract  class Employee {
    //定义成员变量姓名
    private String name;
    //此处注意为什么不定义int类型：工号身份证等信息不一定只有数字
    private String Id;

    //定义工作的方法
    public  abstract void work();

    //由于成员变量为私有，所以必须用set、get方法调用获取
    public void setName(String name) {
        this.name = name;
    }
    public void setId(String Id) {
        this.Id = Id;
    }

    public String getName() {
        return name;
    }
    public String getId() {
        return Id;
    }


}

2）子类
研发部员工类：

/*
 * 定义研发员工类
 * 属于员工的一种，可继承员工类
 * 
 * 本次没有特殊作用，但以后会有
 * 可以给自己的员工定义只属于自己的属性
 * 例如：private double money  ，则属于本类中的员工才有
 */
public abstract class Develop extends Employee{

}

维护部员工类：

/*
 * 定义维护员工类，属于员工类，
 * 可继承员工类
 * 
 * 本次没有特殊作用，但以后会有
 * 可以给自己的员工定义只属于自己的属性
 * 例如：private double money  ，则属于本类中的员工才有
 * 
 */
public  abstract class Maintainer extends Employee {

}

3）孙子类
JavaEE研发类：

/*
 * 描述JavaEE研发工程师类
 * 属于研发员工类
 * 继承父类重写抽象方法即可
 */
public class JavaEE extends Develop{
    //重写父类的父类的抽象方法work
    public void work() {
        System.out.println(super.getName()+super.getId()+" JavaEE工程师在开发淘宝");
    }
}

Android研发类：

/*
 * 描述Android研发工程师类
 * 属于研发员工类
 */
public class Android extends Develop{
    //重写父类的父类的抽象方法work
    public void work() {
        System.out.println(super.getName()+super.getId()+" Android工程师在研发手机淘宝客户端");
    }
}

网络维护类：

/*
 * 描述的是网络维护工程师
 * 属于维护部的员工，继承维护部类
 */
public class Network extends Maintainer{
    public void work() {
        System.out.println(super.getName()+super.getId()+" 网络工程师在检查网络是否畅通");
    }
}

硬件维护类：

/*
 * 描述的是硬件维护工程师
 * 属于维护部的员工，继承维护部类
 */
public class Hardware extends Maintainer{
    public void work() {
        System.out.println(super.getName()+super.getId()+" 正在修复打印机");
    }
}

4）测试类：

/*
 * 测试员工案例
 * 创建最下面的子类对象
 * 
 */
public class Test {
    public static void main(String[] args) {
        JavaEE ee = new JavaEE();
        Android and = new Android();
        Network net = new Network();
        Hardware hard = new Hardware();

        ee.setName("张三");
        ee.setId("研发部001");
        and.setName("李四");
        and.setId("研发部003");
        net.setName("李强");
        net.setId("维护部006");
        hard.setName("王刚");
        hard.setId("维护部008");

        ee.work();
        and.work();
        net.work();
        hard.work();
    }
}

第4章总结

这里写图片描述

娇小妖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA SE — Day 10

第1章继承 1.1 继承的概念 1.2 继承的格式和作用 1.3 继承的优势及注意事项 1.4 继承-子父类中成员变量的特点 1.5 继承-子父类中成员方法的特点 1.6 方法重写的注意事项第2章抽象类 2.1 抽象类的产生 2.2 抽象方法的定义& 使用方式 2.3 抽象类的特点 2.4 抽象类的细节问题第3章综合案例员工案例第4章总结
复制链接

扫一扫