Java开发实践04-0125

最新推荐文章于 2024-07-13 13:55:40 发布
最新推荐文章于 2024-07-13 13:55:40 发布
阅读量1k 收藏 15
点赞数 27
分类专栏： Java开发实践 文章标签： java 开发语言 ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74378177/article/details/135835356
版权

一、今日内容

1、继承

（1）发生在父子之间父类（基类）

人类：特征：姓名、年龄；行为：吃饭、娱乐

学生类：特征：姓名、年龄、学号；行为：吃饭、娱乐、学习

教师类：特征：姓名、年龄、工号；行为：吃饭、娱乐、讲课

工人类：特征：姓名、年龄、薪水；行为：吃饭、娱乐、工作

（2）公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。使用继承提高了代码的复用性，可维护性以及扩展性。在Java语言中使用extends(扩展)关键字来表示继承关系。

（3）java 只支持单继承，可以有多重继承，一个子类只能有一个父类，而一个父类可以有多个子类（简单来说就是一个孩子一个爹，一个爹可以有多个孩子）

注意：子类 is a 父类

如：public class Worker extends Person{} - 表示Worker类继承自Person类，其中Person类叫做超类、父类、基类；其中Worker类叫做派生类、子类、孩子类。

（4）注意事项

    ① 子类不能继承父类的构造方法和私有方法，但私有成员交量可以被继承只是不能直接访问。

    ② 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码：super()的效果。

super:

通过super，可以访问父类构造方法（通过super的构造方法的代码，必须写在子类构造方法的第一行）；

通过super，可以访问父类的屋性；

通过super，可以访问父类的方法。

    ③ 使用继承必须满足逻辑关系：子类 is a父类，也就是不能滥用继承。

    ④  java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。

2、方法的重写(Override)

（1）方法的重载：方法名相同，参数类型，个数，顺序不同。

（2）基本概念：从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写。

（3）重写的原则：

    ① 要求方法名相同、参数列表相同以及返回值类型相同，以jdk1.5开始允许返回子类类型。

    ② 要求方法的访问权限不能交小，可以相同或者交大。

    ③ 要求方法不能地出更大的异常(异常机制)。

    ④ 声明为static和private的方法不能被重写，但是能够被再次声明。

（4）面试题：重写 （Override）和重载 (Overload）的区别

    ① 发生的位置

        重载：一个类中

        重写：子父类中

    ② 参数列表限制

        重载：必须不同

        重写：必须相同

    ③ 返回值类型

        重载：与返回值类型无关

        重写：返回值类型必须一致

    ④ 访问权限：

        重载：与访问权限无关

        重写：重写后（子）的方法的访问权限不能小于被重写（父）方法的权限

    ⑤ 异常处理：

        重载：跟异常没有关系

        重写：异常范围可以小，但是不能抛出新的异常

3、访问权限

（1）常用的访问权限

访问控制符访问权限本类内部本包中的类子类内部其他包中的类
public公有的okokokok
protected保护的okokokno
啥也不写默认的okoknono
private私有的oknono

no

      a. public修饰的成员可以在任意位置使用；

      b.private修饰的成员只能在本类内部使用；

      c. 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰；

4、包的声明

（1）package 包名;

（2）- 表示声明单层包 package 包名1.包名2包名3..包名 n- 表示多层包，为了便于管理以及解決命名冲突的问题；

5、final关键字

（1）final关键字用于修饰属性、变量（表示变量交为了常量，无法再对其再次进行赋值)。

（2）final修饰的局部交量，只能赋值一次(可以先声明后赋值）。

（3）final修饰的成员变量时，必须在声明时赋值。

（4）final关键字用于修饰类。

（5）final修饰类，不可以被继承。

（6）final关键字用于修饰方法。

（7）final修饰方法，不允许被子类重写。

（8）全局常量 (public static final)

全局常量的命名规范：由一个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写。

6、抽象类

（1）概念：抽象类必须使用abstract class声明

一个抽象类中可以没有抽象方法；抽象方法必须号在抽系类或者接口中。

格式：abstract class 类名 {  // 抽象类

           }

（2）抽象方法

格式：只声明而未实现的方法称为抽象方法（未实现指的是：没有"{ }"方法体），抽象方法必须使用abstract关键字声明。

abstract class类名 {  // 抽象类

    public abstract void 方法名 { };  //抽象方法，只声明而未实现

}

（3）不能被实例化

在抽象类的使用中有几个原则：

    ① 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。

    ② 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写（重写)抽条类中的全部抽象方法。

（4）常见问题

    ① 抽象类能否使用final声明？

不能。因为final属修饰的类是不能有子类的，而抽象关必须有子类才有意义，所以不能。

    ② 抽象类能否有构造方法？

能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

    ③ 抽象类和普通类的区别

      a. 抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public

      b. 抽象类不可以使用new关键字创建对象， 但是在子类创建对象时，抽象父类也会被JVM实例化。

      c. 如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类。

7、接口

（1）概念：如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个美定义成一个接口。

定义格式：

interface 接口名称 {

    全局常量；

    抽象方法；

}

8、面向接口编程思想

（1）这种思想是接口是定义（规范，约束） 与实现（名实分离的原则）的分离。

（2）优点：降低程序的耦合性；易于程序的扩展；有利于程序的维护。

9、全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成，所以接口中的成员定义可以简写：

（1）全局常量编写时，可以省略public static final 关健字，例如：

public static final string INFO = "内容";

简写后：String INFO = "内容";

（2）抽象方法编写时，可以省略public abstract 关键字。例如：

public abstract void print ();

简写后：void print ();

10、接口的实现 implements

接口可以多实现：

格式：

class 子类 implements 父接口1，父接口2...{

}

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1，父接口2...{

}

11、接口的继承

（1）接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承，例如：

interface C extends A, B {

}

（2）注意：如果一个接口要想使用，必须依靠子类。子类（如果不是抽象类的话）要实现接口

（3）面试题：接口和抽象类的区别

    ① 抽条类要被子类继承，接口要被类实现。

    ② 接口只能声明抽象方法，抽条类中可以声明抽象方法，也可以写非抽象方法。

    ③ 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

    ④ 抽象类使用继承来使用，无法多继承。接口使用实现来使用，可以多实现。

    ⑤ 抽象类中可以包含astatic方法，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）。

    ⑥ 接口不能有构造方法，但是抽象类可以有。

12、多态

（1）基本概念：多态主要指同一种事物表现出来的多种形态。

如：饮料：可乐、雪碧、乐虎加多宝、红牛、脉动、…

宠物：猫、狗、乌、小强鱼、…

人：学生、教历工人、保安、⋯

（2）语法格式

父类类型 引用变量名 = new 子类类型();  // 父类型的引用指向子类型的对象【多态的核心】

如：

Person pw = new Worker;
Shape shape = new Rect();
pw.show;

（3）多态的效果

    ① 当父类类型的引用指向子类类型的对家时，父类类型的引用可以直接调用父类独有的方法；

    ② 当父类类型的引用指向子类类型的对象时，，父类类型的引用不可以直接调用子类独有的方法；

    ③ 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本；

    ④ 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本；

（4）引用数据类型之间的转换

    ① 引用数据类型之间的转换方式有两种：自动类型转换和强制类型转换。其中自动类型转换主要指小类型向大类型的转换，也就是子类转换为父类。其中强制类型转换主要指大类型向小类型的转换，也就是父类转换为子类。

    ② 引用数据类型之间的转换必须发生在父子类之间，否则编译报错。

    ③ 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。

    ④ 为了避免上述错误的发生，应该在强转之前进行判断，格式如下：if(引用变量 instanceof 数据类型) - 判断引用变量指向的对象是否为后面的数据类型。

（5）实际意义：多态的实际意义在于屏蔽不同子类的差昇性实现通用的编程带来不同的效果。

二、代码

1、继承 com.jicheng

（1）Person

继承--父类：人类

package com.jicheng;

/**
 * @Author: ydh 2303
 * @description: 继承--父类：人类
 * @Date: 2024/1/25 8:14
 * @Version: 1.0
 */
public class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("父类无参构造方法");
    }

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

    public void eat(){

    }

    public void play(){

    }
}

package com.jicheng;

/**
 * @Author: ydh 2303
 * @description: 继承--父类测试类
 * @Date: 2024/1/25 8:24
 * @Version: 1.0
 */
public class PersonTest {
    public static void main(String[] args) {
        Student student=  new Student();

    }
}

运行结果：

（2）Student

继承--子类：学生

package com.jicheng;

/**
 * @Author: ydh 2303
 * @description: 继承--子类：学生
 * @Date: 2024/1/25 8:16
 * @Version: 1.0
 */
public class Student extends Person {
    private int studentId;

    public Student(){
        super();
    }

    public Student(int studentId) {
        this.studentId = studentId;
    }

    public Student(String name, int age, int studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    public void study(){

    }
}
（3）Teacher

继承--子类：教师

package com.jicheng;

/**
 * @Author: ydh 2303
 * @description: 继承--子类：教师
 * @Date: 2024/1/25 8:17
 * @Version: 1.0
 */
public class Teacher extends Person {

    private int teacherId;

    public void teach(){

    }
}
（4）Worker

继承--子类：工人

package com.jicheng;

/**
 * @Author: ydh 2303
 * @description: 继承--子类：工人
 * @Date: 2024/1/25 8:20
 * @Version: 1.0
 */
public class Worker extends Person {

    private int salary;

    public void work() {

    }
}

2、继承 com.animal 

（1）Animal

编程实现Animal类的封装，特征有：名字和毛色，要求提供打印所有特征的方法。编桯实现Dog类的封装，并继承自Animal类，该类的特征有：牙齿数量，要求提供打印所有特征的方法；编程实现DogTest类，在main方法中分别使用无参和有参方式构造Dog类型对象并打印特征。

package com.animal;

/**
 * @Author: ydh 2303
 * @description: ：编程实现Animal类的封装，特征有：名字和毛色，要求提供打印所有特征的方法。
 *                编桯实现Dog类的封装，并继承自Animal类，该类的特征有：牙齿数量，要求提供打印所有特征的方法；
 *                编程实现DogTest类，在main方法中分别使用无参和有参方式构造Dog类型对象并打印特征。
 * @Date: 2024/1/25 8:57
 * @Version: 1.0
 */
public class Animal {
    private String name;
    private String color;

    public Animal() {
    }

    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void show(){
        System.out.println("我的名字叫做" + getName() + "，我的毛色是" + getColor() + "色。");
    }
}
（2）Dog

编桯实现Dog类的封装，并继承自Animal类，该类的特征有：牙齿数量，要求提供打印所有特征的方法；

package com.animal;

/**
 * @Author: ydh 2303
 * @description: 编桯实现Dog类的封装，并继承自Animal类，该类的特征有：牙齿数量，要求提供打印所有特征的方法；
 * @Date: 2024/1/25 8:59
 * @Version: 1.0
 */
public class Dog extends Animal {
    private  int teethNumber;

    public Dog(){}

    public Dog(int teethNumber) {
        this.teethNumber = teethNumber;
    }

    public Dog(String name, String color, int teethNumber) {
        super(name, color);
        this.teethNumber = teethNumber;
    }

    public int getTeethNumber() {
        return teethNumber;
    }

    public void setTeethNumber(int teethNumber) {
        this.teethNumber = teethNumber;
    }

    @Override
    public void show(){
        System.out.println("我叫" + getName() + "，颜色是：" + getColor() + "，牙齿数量是：" + getTeethNumber());
    }
}

package com.animal;
/**
 * @Author: ydh 2303
 * @description: 编程实现DogTest类，在main方法中分别使用无参和有参方式构造Dog类型对象并打印特征。
 * @Date: 2024/1/25 9:02
 * @Version: 1.0
 */
public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
        Dog dog1 = new Dog("阿拉斯加", "粉色", 1);
        dog1.show();
    }
}
（3）DogTest

编程实现DogTest类，在main方法中分别使用无参和有参方式构造Dog类型对象并打印特征。

package com.animal;
/**
 * @Author: ydh 2303
 * @description: 编程实现DogTest类，在main方法中分别使用无参和有参方式构造Dog类型对象并打印特征。
 * @Date: 2024/1/25 9:02
 * @Version: 1.0
 */
public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
        Dog dog1 = new Dog("阿拉斯加", "粉色", 1);
        dog1.show();
    }
}

 运行结果：

3、com.account

（1）Account

自定义抽象类Account实现封装，特征：账户余额（balance），在该类中提供一个计算利息并返回的抽象方法；在自定义FixedAccount类继承Account类并重写抽象方法；要求在main方法中使用多态方法；方式构造对象并存入1000元，计算利息后打印出来（其中利率0.003，时间1年）。

package com.account;
/**
 * @Author: ydh 2303
 * @description: 自定义抽象类Account实现封装，特征：账户余额（balance），在该类中提供一个计算利息并返回的抽象方法；
 *               在自定义FixedAccount类继承Account类并重写抽象方法；
 *               要求在main方法中使用多态方法;
 *               方式构造对象并存入1000元，计算利息后打印出来（其中利率0.003，时间1年）。
 * @Date: 2024/1/25 15:51
 * @Version: 1.0
 */
public abstract class Account {

    private double balance;

    //计算利息
    public abstract double getInterest(double index, double time);

    public Account() {
    }

    public Account(double balance) {
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

}
（2）FixedAccount

在自定义FixedAccount类继承Account类并重写抽象方法

package com.account;

import com.finaltest.A;

/**
 * @Author: ydh 2303
 * @description:
 * @Date: 2024/1/25 17:31
 * @Version: 1.0
 */
public class FixedAccount extends Account {
    public FixedAccount() {
    }

    public FixedAccount(double balance) {
        super(balance);
    }

    @Override
    public double getInterest(double index, double time) {
        return getBalance() * index * time;
    }

}
（3）AccountTest

要求在main方法中使用多态方法；方式构造对象并存入1000元，计算利息后打印出来（其中利率0.003，时间1年）。

package com.account;

/**
 * @Author: ydh 2303
 * @description:
 * @Date: 2024/1/25 17:34
 * @Version: 1.0
 */
public class AccountTest {
    public static void main(String[] args) {

        Account acc = new FixedAccount(1000);

        System.out.println("本金：" + acc.getBalance() + "，利息：" + acc.getInterest(0.003, 1));

    }
}

运行结果：

4、com.Person01

（1）Person

抽象类：教师、学生、护士、军人；自定义抽象类Person类的封装，特征：姓名、年龄、身高、无参构造方法，在该类中提供一个说话say()的抽象方法；自定义Nurse类继承Person类，提供无参构造方法，并重写抽象方法；要求在main方法中创建一个Nurse类型对象，查看调用Nurse构造方法和Person构造方法。

package com.Person01;

/**
 * @Author: ydh 2303
 * @description: 抽象类：教师、学生、护士、军人
 *               自定义抽象类Person类的封装，特征：姓名、年龄、身高、无参构造方法，在该类中提供一个说话say()的抽象方法；
 *               自定义Nurse类继承Person类，提供无参构造方法，并重写抽象方法；
 *               要求在main方法中创建一个Nurse类型对象，查看调用Nurse构造方法和Person构造方法。
 * @Date: 2024/1/25 15:38
 * @Version: 1.0
 */
public abstract class Person {

    String name;
    int age;
    double height;

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public void show(){
        System.out.println("我是Person...show()");
    }

    public abstract void say(); // 抽象方法没有方法体

}
（2）Nurse

自定义抽象类Person类的封装，特征：姓名、年龄、身高、无参构造方法，在该类中提供一个说话say()的抽象方法

package com.Person01;
/**
 * @Author: ydh 2303
 * @description: 护士 自定义Nurse类继承Person类，提供无参构造方法，并重写抽象方法；
 * @Date: 2024/1/25 15:42
 * @Version: 1.0
 */

public class Nurse extends Person {

    public Nurse() {
    }

    @Override
    public void say() {
        System.out.println("你受伤了！");
    } //重写

}
（3）Student

自定义Nurse类继承Person类，提供无参构造方法，并重写抽象方法

package com.Person01;

/**
 * @Author: ydh 2303
 * @description: 学生
 * @Date: 2024/1/25 15:43
 * @Version: 1.0
 */
public class Student extends Person {

    @Override
    public void show(){
        System.out.println("我是Student...show()");
    }

    @Override
    public void say() {
    }
}
（4）PersonTest

要求在main方法中创建一个Nurse类型对象，查看调用Nurse构造方法和Person构造方法。

package com.Person01;
/**
 * @Author: ydh 2303
 * @description: 要求在main方法中创建一个Nurse类型对象，查看调用Nurse构造方法和Person构造方法。
 * @Date: 2024/1/25 15:49
 * @Version: 1.0
 */
public class PersonTest {
    public static void main(String[] args) {

        Nurse nurse = new Nurse();
        nurse.say();

        Person person = new Student();
        person.show(); //在编译阶段Persons show()方法；在运行阶段，调用的是student show()方法。
    }
}

运行结果：

5、com.Person02

（1）Person

编程实现Person类的封装，特征有：姓名、年龄，要求提供打印所有特征的方法； 编程实现worker类的封装的封装并继承自Person类，特征有：薪水；编程实现PersonWorkerTest类，在main方法中分別创建Person和worker类型对象并打印特征；编程实现Person类型的引用指向worker类型的形象，并打印特征。

package com.Person02;
/**
 * @Author: ydh 2303
 * @description: 编程实现Person类的封装，特征有：姓名、年龄，要求提供打印所有特征的方法；
 *               编程实现worker类的封装的封装并继承自Person类，特征有：薪水；
 *               编程实现PersonWorkerTest类，在main方法中分別创建Person和worker类型对象并打印特征；
 *               编程实现Person类型的引用指向worker类型的形象，并打印特征。
 * @Date: 2024/1/25 16:19
 * @Version: 1.0
 */
public class Person {

    private String name;
    private int age;

    public Person() {
    }

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

    public void show(){
        System.out.println("Person{ name=" + name + " , age=" + age + " }");
    }
}
（2）Worker

 编程实现worker类的封装的封装并继承自Person类，特征有：薪水

package com.Person02;

import com.sun.xml.internal.ws.addressing.WsaActionUtil;

/**
 * @Author: ydh 2303
 * @description: 编程实现worker类的封装的封装并继承自Person类，特征有：薪水；
 * @Date: 2024/1/25 16:18
 * @Version: 1.0
 */
public class Worker extends Person {

    private double salary;

    @Override
    public void show() {
        System.out.println("Worker{ salary=" + salary + " }");
    }
}
（3）PersonWorkerTest

编程实现PersonWorkerTest类，在main方法中分別创建Person和worker类型对象并打印特征；编程实现Person类型的引用指向worker类型的形象，并打印特征

package com.Person02;

import com.sun.xml.internal.ws.addressing.WsaActionUtil;

/**
 * @Author: ydh 2303
 * @description: 编程实现worker类的封装的封装并继承自Person类，特征有：薪水；
 * @Date: 2024/1/25 16:18
 * @Version: 1.0
 */
public class Worker extends Person {

    private double salary;

    @Override
    public void show() {
        System.out.println("Worker{ salary=" + salary + " }");
    }
}

运行结果：

6、com.run

（1）Runner

编程实现Runner接口；编程实现Hunter接口，并且Hunter接口继承Runner接口；自定义一个人类Chinese类实现Hunter接口；自定义主类实现调用。

package com.run;

/**
 * @Author: ydh 2303
 * @description: 编程实现Runner接口；
 *               编程实现Hunter接口，并且Hunter接口继承Runner接口；
 *               自定义一个人类Chinese类实现Hunter接口；
 *               自定义主类实现调用。
 * @Date: 2024/1/25 17:51
 * @Version: 1.0
 */
public interface Runner {

    //public可省略

    public void running();
}
（2）Hunter

编程实现Hunter接口，并且Hunter接口继承Runner接口

package com.run;

/**
 * @Author: ydh 2303
 * @description: 编程实现Hunter接口，并且Hunter接口继承Runner接口；
 * @Date: 2024/1/25 17:51
 * @Version: 1.0
 */
public interface Hunter extends Runner {

    void hunt();
}
（3）Chinese

自定义一个人类Chinese类实现Hunter接口

package com.run;

/**
 * @Author: ydh 2303
 * @description: 自定义一个人类Chinese类实现Hunter接口
 * @Date: 2024/1/25 18:09
 * @Version: 1.0
 */
public class Chinese implements Hunter {

    @Override
    public void hunt() {
        System.out.println("抓到一只小白兔！");
    }

    @Override
    public void running() {
        System.out.println("正在全力地奔跑！");
    }
}
（4）ChineseTest

自定义主类实现调用

package com.run;

/**
 * @Author: ydh 2303
 * @description: 自定义主类实现调用
 * @Date: 2024/1/25 18:11
 * @Version: 1.0
 */
public class ChineseTest {
    public static void main(String[] args) {
        //接口类型的引用指向实现类的对象，形成多态
        Runner runner = new Chinese();
        runner.running();
        Hunter hunter = new Chinese();
        hunter.hunt();
    }
}

运行结果：

7、com.shape

（1）Shape

自定义矩形Rect类，特征有：横纵坐标 长度及宽度，提供无参，全参构造，setget方法要求交现封装并提供打印方法；自定义园形Circle类，特征有：横纵坐标 半径，提供参，全参构造，set/get方法，要求实现封装并提供丁印方法；提取共性自定义图形Shape类，提供无参，全参构造，set/get方法；自定义ShapeTest类，自定义成员方法实现既能打印矩形又能打印圆形的方法并调用。

package com.shape;

/**
 * @Author: ydh 2303
 * @description: 自定义矩形Rect类，特征有：横纵坐标 长度及宽度，提供无参，全参构造，setget方法要求交现封装并提供打印方法;
 *               自定义圆形Circle类，特征有：横纵坐标 半径，提供参，全参构造，set/get方法，要求实现封装并提供丁印方法；
 *               提取共性自定义图形Shape类，提供无参，全参构造，set/get方法；
 *               自定义ShapeTest类，自定义成员方法实现既能打印矩形又能打印圆形的方法并调用(最后一个成员方法选做)
 * @Date: 2024/1/25 9:42
 * @Version: 1.0
 */
public class Shape {

    private int x;
    private int y;

    public Shape() {
    }

    public Shape(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void show(){
        System.out.println("Shape[ x=" + getX() + ", y=" + getY() + " ]");
    }

}
（2）Rect

自定义矩形Rect类，特征有：横纵坐标 长度及宽度，提供无参，全参构造，setget方法要求交现封装并提供打印方法

package com.shape;

/**
 * @Author: ydh 2303
 * @description: 自定义矩形Rect类，特征有：横纵坐标 长度及宽度，提供无参，全参构造，setget方法要求交现封装并提供打印方法;
 * @Date: 2024/1/25 9:42
 * @Version: 1.0
 */
public class Rect extends Shape {

    private double length;
    private double width;

    public Rect() {
    }

    public Rect(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public Rect(int x, int y, double length, double width) {
        super(x, y);
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public void show() {
        System.out.println("Rect[ x=" + getX() + ", y=" + getY() + ", length=" + length + ", width=" + width + "]");
    }
}
（3）Circle

自定义园形Circle类，特征有：横纵坐标 半径，提供参，全参构造，set/get方法，要求实现封装并提供丁印方法

package com.shape;

/**
 * @Author: ydh 2303
 * @description: 自定义圆形Circle类，特征有：横纵坐标 半径，提供参，全参构造，set/get方法，要求实现封装并提供丁印方法；
 * @Date: 2024/1/25 9:42
 * @Version: 1.0
 */
public class Circle extends Shape {

    private double r;

    public Circle() {
    }

    public Circle(double r) {
        this.r = r;
    }

    public Circle(int x, int y, double r) {
        super(x, y);
        this.r = r;
    }

    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }

    @Override
    public void show() {
        System.out.println("Circle[ x=" + getX() + ", y=" + getY() + ", r=" + getR() + "]");
    }
}
（4）ShapeTest

自定义ShapeTest类，自定义成员方法实现既能打印矩形又能打印圆形的方法并调用

package com.shape;

/**
 * @Author: ydh 2303
 * @description: 自定义ShapeTest类，自定义成员方法实现既能打印矩形又能打印圆形的方法并调用(最后一个成员方法选做)
 * @Date: 2024/1/25 9:52
 * @Version: 1.0
 */
public class ShapeTest {

    public static void printRect(Rect rect){
        rect.show();
    }

    public static void printCirecle(Circle circle){
        circle.show();
    }

    public static void printShape(Shape shape){
        shape.show();
    }

    // static修饰的方法只能调用静态的方法
    public static void main(String[] args) {

//        Shape shape = new Shape(3, 4);
//        shape.show();
//        Rect rect = new Rect(1, 2, 3, 4);
//        rect.show();
//        Circle circle = new Circle(1, 2 ,4 );
//        circle.show();

//        printRect(new Rect(1, 2, 3, 4));
//        printCirecle(new Circle(1, 2 ,4 ));

//        //父类型  引用变量名 = new 子类类型();
//        Shape shape = new Rect(1, 2, 3, 4);
//        shape.show();
//        Shape shape1 = new Circle(1, 2, 4);
//        shape1.show();

        printShape(new Shape(3, 4));
        printShape(new Rect(1, 2, 3, 4));
        printShape(new Circle(1, 2, 4));
    }
}

运行结果：

三、总结

今日学习了继承、方法的重写、访问权限、包的声明、final关键字、抽象类、接口、面向接口编程思想、全局常量和抽象方法的简写、接口的实现 implements、接口的继承、多态等内容，老师还分享了一些就业知识，受益匪浅！

yyy001..
关注
  • 27
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里Java开发手册-黄山版
10-25
每个维度又细分了多个二级子目录，确保了涵盖广泛而深入的开发实践。 手册中，规约按照约束力和故障敏感性的不同，被分为【强制】、【推荐】、【参考】三大类别。这不仅有助于开发者明确哪些规则必须遵守，哪些可以...
Java开发手册---泰山版.zip
02-04
《Java开发手册---泰山版》是一本专门为Java开发者编写的指南，它涵盖了Java编程语言的各个方面，旨在提高开发效率，保证代码质量，并推动团队间的代码规范。这份文档详细阐述了Java编程的最佳实践、常见问题解决...
头歌java 实训 答案 代码 java入门
热门推荐
个人博客地址https://sun98k.github.io/
12-06 17万+
头歌java实训参考答案，文章附带目录，谢谢大家的支持。祝大家实训满分。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 14万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
计算机学院实习报告3000字（Java开发实习）--持续更新中，多个专业，以及版本
不忘初心，砥砺前行
02-26 4万+
第一篇 适合开发 第二篇 适合运维 第三篇 适合测试
关于JAVA的一些基本内容-笔记
私信up主，有惊喜
09-10 9万+
此外，我们还将分析Java在企业级应用开发中的未来趋势和发展方向，以及Java和其他编程语言（如Go和Rust）之间的竞争和比较。本节将介绍Java的未来发展趋势和新特性，包括Java 9模块化系统、Java 10局部变量类型推断、Java 11的新特性等，并给出Java在云计算和人工智能领域的应用和竞争情况，同时也会对其他编程语言的发展进行分析和比较。本节将介绍Java在企业级应用开发中的基本概念、技术架构和常用框架，包括EJB、Spring企业版、Java EE等，并给出一些企业级应用开发的应用案例。
小程序微信支付实践案例-JAVA
huangdi1309的博客
11-22 5748
微信支付接入
【JAVA-Day68】异常处理的奥秘：深度解析 Java try-catch-finally 机制，高效应对异常问题
沉淀、分享、成长，让自己和他人都能有所收获！
12-18 1万+
在软件开发中，异常处理是保障程序稳定性的重要一环。本文将深入研究 Java 中的 try-catch-finally 机制，通过对每个环节的详细解析和实际案例演示，帮助读者更好地理解和应用异常处理的核心知识点。在某些情况下，我们可能需要抛出自定义异常来更好地表示特定的错误情况，以便于后续的处理。// 自定义异常的实现try {// 可能抛出异常的代码块if (/*某个条件*/) {throw new CustomException("发生自定义异常");// 处理自定义异常。
头歌实践-Java继承与多态
一个专注于客户端开发的技术er，不定期更新Android，Flutter，HormonyOS等方向的使用心得和感悟
10-28 6783
头歌实践作业第1关：练习-Java继承和多态之final关键字第2关：学习-Java继承和多态之对象类型的转换任务描述相关知识向上转型向下转型编程要求第3关：练习-Java继承和多态之方法重载任务描述编程要求第4关：练习-Java继承和多态之方法重写任务描述编程要求 第1关：练习-Java继承和多态之final关键字 /** * 按照代码文件中提供的注释完成 Demo 类的编写，使得程序正常输出。 */ class DemoTest{ int i = 10; } // 请在下面的Begin-En
Java后端开发常用规范
IT利刃出鞘的博客
08-08 5809
本文介绍Java后端开发的一些规范。持续更新。 本规范是本人总结出来的，可提高项目的可维护性、提高扩展性、提高开发速度。本文可以解决项目中效率低下、难以维护、让人心累的痛点等问题。
Java - XXL-JOB
小泽的博客
11-03 3584
说到定时任务想必每一个开发人员都不陌生，开启定时任务的方式也多种多样，如: @Scheduled，Quertz，Elastic-Job, xxl-job等。 xxl-job作为目前业界流行的分布式任务调度框架，受到越来越多的人的信任，越来越多的公司也接入了xxl-job作为定时任务统一调度中心。 想了解xxl-job的可以去github等平台学习。 在这里只介绍下项目中如何使用xxl-job，如何在任务管理界面配置定时任务。 xxl-job包依赖，maven引入 <depend
「小明赠书活动」第四期《Java开发坑点解析：从根因分析到最佳实践》
小明的Java问道之路
05-28 2万+
「小明赠书活动」第四期《Java开发坑点解析：从根因分析到最佳实践》
大型网站系统与Java中间件开发实践 - 曾宪杰.mobi 带目录、书签、超清文字版
05-16
大型网站系统与Java中间件开发实践 - 曾宪杰.mobi 带目录、书签、超清文字版
Java开发手册-代码规范
03-22
《Java开发手册-代码规范》是一本旨在帮助Java开发者提高代码质量和可维护性的指南。该手册由阿里巴巴集团编写，总结了多年的开发经验和最佳实践。以下是该手册的主要内容： 命名规范：包括类名、方法名、变量名等...
JAVA开发实践规范
07-27
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 479
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
配置Java开发环境
Broken_x的博客
07-10 1513
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 492
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 477
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
Java-Web应用开发技术与案例教程-教学课件-张继军-第章JDBC数据库访问技术完整版资料.ppt
11-14
"Java-Web应用开发技术与案例教程，专注于JDBC数据库访问技术的讲解，由张继军主讲的教学课件，内容覆盖了JDBC技术的各个方面，包括驱动程序接口、驱动程序管理器、数据库连接、SQL语句执行以及结果集处理等。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值