第九周Java作业

最新推荐文章于 2023-03-13 10:16:39 发布

小宇飞刀

最新推荐文章于 2023-03-13 10:16:39 发布

阅读量1.7k

点赞数 6

分类专栏： Java教学 Java

本文链接：https://blog.csdn.net/xieyunc/article/details/102660207

版权

Java 同时被 2 个专栏收录

45 篇文章 2 订阅

订阅专栏

Java教学

28 篇文章 4 订阅

订阅专栏

本周主题：面向对象程序设计（三）

Java 抽象类
Java 接口
Java 包(package)

一、Java 抽象类

1、抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

在Java语言中使用abstract class来定义抽象类。

[修饰符] abstract class <类名> {

    //...

}

2、举个例子

应用场景分析：

某公司雇员示例：
需求：
        程序员　：姓名，工号，薪水，工作内容
        项目经理：姓名，工号，薪水，工作内容，还有奖金
        对给出需求进行数据建模
分析：

        在这个问题领域中，先找出涉及的对象。

        通过名词进行提炼：
        程序员：
            属性：姓名，工号，薪水
            行为：工作
        项目经理：
            属性：姓名，工号，薪水，奖金
            行为：工作

        程序员和经理不存在直接继承关系
        但是程序员和经理却具有共性内容
        因此可设计一个共同的抽象类（雇员类Employee），由它派生并实现程序员类（Programmer）和经理类（Manager）

雇员类--Employee

/**
 * 文件名：Employee.java
 * 功能描述：雇员类（抽象类）
 */
abstract class Employee {
    String name; //姓名
    String id;   //工号
    double pay;  //薪水
    Employee(String name,String id,double pay)
    {
        this.name = name;
        this.id = id;
        this.pay = pay;
    }
    public abstract void work();
}

经理类--Manager

/**
 * 文件名：Manager.java
 * 功能描述：经理类
 */
class Manager extends Employee {
    int bonus; //奖金
    public Manager(String name,String id,double pay,int bonus) {
        super(name,id,pay);
        this.bonus = bonus;
    }

    public void work() {
        System.out.println(this.getClass()+":");
        System.out.printf("name:%-10s\tid=%-10s\tpay=%,-15.2f\tbonus=%,-10d\n",name,id,pay,bonus);
    }
}

程序员类--Programmer

/**
 * 文件名：Programmer.java
 * 功能描述：程序员类
 */
class Programmer extends Employee{
    public Programmer(String name,String id,double pay) {
        super(name,id,pay);
    }

    public void work() {
        System.out.println(this.getClass()+":");
        System.out.printf("name:%-10s\tid=%-10s\tpay=%,-15.2f\n",name,id,pay);
    }

}

测试类--AbstractTest

/**
 * 文件名：AbstractTest.java
 * 功能描述：对Employee/Manager/Programmer进行测试
 */
public class AbstractTest {
    public static void main(String[] args) {
        Manager m = new Manager("张三丰", "1001", 12000.00, 6000);
        m.work();

        Programmer p = new Programmer("小宇飞刀", "2001", 9500.00);
        p.work();
    }
}

执行结果：

二、Java 接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

举个例子

汽车类接口----ICar

//汽车接口
interface ICar {
    //获取汽车名字
    String getName();
    //获取汽车售价
    double getPrice();
}

奔驰汽车类----Benz

//奔驰汽车
class Benz implements ICar {
    String color = "黑色"; //颜色

    @Override
    public String getName() {
        return color+"奔驰";
    }

    @Override
    public double getPrice() {
        double price = 300000.00; //车价
        if (color.equals("红色"))
            price += 10000.00; //红色加价1万

        return price;
    }

    Benz(String color) {
        this.color = color;
    }

}

吉利汽车类----Geely

//吉利汽车
class Geely implements ICar {
    String color = "黑色"; //颜色

    @Override
    public String getName() {
        return color+"吉利";
    }

    @Override
    public double getPrice() {
        double price = 100000.00; //车价
        return price;
    }

    Geely(String color) {
        this.color = color;
    }

}

汽车销售店类----CarShop

//汽车销售店
class CarShop {
    private String shopName; //店名
    private int count = 0; //销售数量
    private double money = 0.00; //销售金额

    public String getShopName() {
        return shopName;
    }

    double getMoney() {
        return money;
    }

    int getCount() {
        return count;
    }

    CarShop(String shopName) {
        this.shopName = shopName;
    }

    //销售汽车
    void sellCar(ICar car) {
        System.out.println(String.format("%s售出%s1台,单价￥%,.2f元",shopName,car.getName(),car.getPrice()));
        count ++;
        money += car.getPrice();
    }
}

测试类----CarTest

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

        CarShop aShop = new CarShop("九江汽车商行");

        aShop.sellCar(new Benz("红色"));
        aShop.sellCar(new Benz("银色"));
        aShop.sellCar(new Geely("白色"));

        System.out.printf("%s总销量：%d台，销售额：￥%,.2f元\n",aShop.getShopName(),aShop.getCount(),aShop.getMoney());
        System.out.println("----------------------------------------------");

        CarShop bShop = new CarShop("南昌奔驰4S店");
        bShop.sellCar(new Benz("红色"));
        bShop.sellCar(new Benz("红色"));
        bShop.sellCar(new Benz("白色"));
        bShop.sellCar(new Benz("黑色"));

        System.out.printf("%s总销量：%d台，销售额：￥%,.2f元\n",bShop.getShopName(),bShop.getCount(),bShop.getMoney());
        System.out.println("----------------------------------------------");

        CarShop cShop = new CarShop("赣州吉利4S店");
        cShop.sellCar(new Geely("红色"));
        cShop.sellCar(new Geely("黑色"));
        System.out.printf("%s总销量：%d台，销售额：￥%,.2f元\n",cShop.getShopName(),cShop.getCount(),cShop.getMoney());

    }
}

执行结果：

三、抽象与接口相结合的经典实例

普通门与报警门的案例分析见此贴的第四部分：https://blog.csdn.net/xieyunc/article/details/102651225

抽象类---Door

/**
 * 文件名：Door.java
 * 功能描述：“门”的抽象类
 */
public abstract class Door {
    private int height; //门的高度
    private int width;  //门的宽度
    private String color;  //门的颜色
    private double price;  //门的单价

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Door(int height, int width, String color, double price) {
        this.height = height;
        this.width = width;
        this.color = color;
        //this.price = price;
        setPrice(price);
    }

    public void summary() { //门的简介
        System.out.println(String.format("高:%dcm,宽:%dcm,颜色:%s，单价：%,.2f元",height,width,color,price));
    }

    abstract void open();  //开门功能
    abstract void close(); //关门功能
}

警报接口--IAlarm

/**
 * 文件名：IAlarm.java
 * 功能描述：警报功能接口
 */
public interface IAlarm {
    public void alarm();  //警报功能
}

普通门类--RoomDoor

/**
 * 文件名：RoomDoor.java
 * 功能描述：普通房间门类
 */
public class RoomDoor extends Door {
    public RoomDoor(int height, int width, String color, double price) {
        super(height, width, color, price);
    }

    @Override
    void open() {
        System.out.println("正在开门……");
    }

    @Override
    public void summary() {
        System.out.print("类型：普通门，规格：");
        super.summary();
    }

    @Override
    void close() {
        System.out.println("正在关门……");
    }
}

带密码和报警功能的防盗门类--PasswordDoor

/**
 * 文件名：PasswordDoor.java
 * 功能描述：带密码和报警功能的防盗门
 */

import java.util.Scanner;

public class PasswordDoor extends Door implements IAlarm {
    private String password; //用于存储的密码门的认证密码信息

    public void setPassword(String password) {
        this.password = password;
    }

    public PasswordDoor(int height, int width, String color, double price) {
        super(height, width, color, price);
        setPassword("000000");//防盗门的初始密码为6个“0”
    }

    @Override
    public void summary() {
        System.out.print("类型：防盗门，规格：");
        super.summary();
    }

    @Override
    public void alarm() {
        System.out.println("发出报警声音，同时自动拔打报警电话……");
    }

    @Override
    void open() {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入密码：");
        String myPassword = input.nextLine();
        if (myPassword.equals(password)) {
            System.out.println("正在开门……");
        }
        else {
            System.out.println("非法用户正在试图开门……");
            alarm();//报警
        }
        input.close();
    }

    @Override
    void close() {
        System.out.println("正在关门……");
    }
}

测试类--DoorTest

/**
 * 文件名：DoorTest.java
 * 功能描述：Door测试类
 */
public class DoorTest {
    public static void main(String[] args) {
        Door aDoor = new RoomDoor(220,150,"红色",800.00);
        aDoor.summary();//简介
        aDoor.open();
        aDoor.close();

        aDoor = new PasswordDoor(260,180,"金色",3000);
        aDoor.summary();//简介

        aDoor.open();

        if (aDoor instanceof PasswordDoor) { //更换了防盗门的密码
            ((PasswordDoor)aDoor).setPassword("admin000");
            System.out.println("更换了防盗门的密码！");
        }
        aDoor.open();
        aDoor.close();

    }
}

运行结果：

四、Java 包(package)

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

1、包的作用

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

例如，一个Something.java 文件它的内容为：

package net.java.util; 

public class Something{

    ... 

}

那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。

以下是一些 Java 中的包：

java.lang----打包基础的类
java.io----包含输入输出功能的函数

开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。

由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。

2、import 关键字---使用包

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import package1[.package2…].(classname|*);

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

3、举个例子：

以“小宇飞刀开着玛莎拉蒂买橘子”的场景为例，设计相应的类及相关测试Demo，功能类和测试类分别存放在不同的包下，类、包规划如下：

Idea中显示的包结构：

汽车类--Car

/**
 * 文件名：Car.java
 */
package com.xyfd.common;

public class Car {
    String type;  //车型

    public Car(String type) {
        this.type = type;
    }
}

水果类--Fruit

/**
 * 文件名：Fruit.java
 */
package com.xyfd.common;

public class Fruit {
    String name; //水果名称

    public Fruit(String name) {
        this.name = name;
    }
}

个人类--Person

/**
 * 文件名：Person.java
 */
package com.xyfd.common;

public class Person {
    private String name; //姓名
    private char sex;
    private int height;
    private int age;

    /*
     * Q：Person类文件在使用Car和Fruit时，为何无须导入Car和Fruit的包信息？
     * A：因为Person和Car、Fruit类处于同一个包下，包内部的不同类之间互相访问时无需导入包信息，
     *    故在此处无需使用import导入Car和Fruit类的包信息。
    */
    private Car car;  //车型
    private Fruit fruit; //水果


    public Person(String name,char sex,int height,int age) {
        this.name = name;
        this.sex = sex;
        this.height = height;
        this.age = age;
    }

    public void doing() { //对象正在干什么……
        System.out.printf("我叫%s,%c,身高%dcm,今年%d岁！\n",name,sex,height,age);
        System.out.println("我正在开着 "+car.type+" 去买 "+fruit.name+" ……");
    }

    public void drive(String carType) {
        this.car = new Car(carType);
    }

    public void buyFruit(String fruitName) {
        fruit = new Fruit(fruitName);
    }
}

测试类--TestDemo

/**
 * 文件名：TestDemo.java
 */
package com.xyfd.test; //TestDemo类所在的包，与Car、Fruit、Person处于不同的包。

import com.xyfd.common.Person; //导入要引用的类，如果要导入包下的所有类可写为：com.xyfd.common.*;

public class TestDemo {
    public static void main(String[] args) {
        Person myMaster = new Person("小宇飞刀",'男',170,27);

        myMaster.drive("玛莎拉蒂");
        myMaster.buyFruit("橘子");

        myMaster.doing(); //某人正在干嘛呢……

    }
}

运行结果：

五、演示DEMO源代码在github上的仓库地址：

https://github.com/xieyunc/java_demo.git

小宇飞刀

关注

6
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
第九周Java作业

本周主题：面向对象程序设计（三）Java 抽象类 Java 接口 Java 包(package)一、Java 抽象类1、抽象类的概念在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方...
复制链接

扫一扫

专栏目录