【JAVA系列】Java中的包、类的继承、多态、抽象类与接口

最新推荐文章于 2023-07-28 09:49:31 发布
最新推荐文章于 2023-07-28 09:49:31 发布
阅读量1.6k 收藏 30
点赞数 25
分类专栏： 玩转JAVA系列 文章标签： 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46913665/article/details/121339856
版权

文章目录

前言

一、包及访问权限

1.什么是包？

要理解什么是包，我们需要先设想一个情境——当我们在开发一个大型程序时，不同的开发人员都可能会写一个Test类，那么在这种情况下，就会发生冲突导致代码不能编译通过。这个时候就需要通过package来帮忙，而package就是包。

package时在使用多个类或接口时，为了避免名称重复而采用的一种措施。
使用包的主要目的是保证类的唯一性

package声明如下：

package package 名称；

经过package的声明之后，同一文件内的接口或类就都会被纳入相同的package中。

【注意】
1.创建包的时候，包名一定要小写。
在这里插入图片描述

2.创建的包，一定要在前面加上package包的路径。
在这里插入图片描述3.包名要和代码路径相匹配. 例如创建 com.mrzhu.demo 的包, 那么会存在一个对应的路径 com/mrzhu/demo来存
储代码

在这里插入图片描述
4.如果一个类没有 package 语句, 则该类被放到一个默认包中

2.如何导入包？

通过import命令，可将某个package内的整个类导入。

例如：
在这里插入图片描述
在这里，大家想一个问题，如果我们每次都需要导入指定的类的话，那么代码是不是就需要写得很多了呀？

在这里插入图片描述那么，我们有什么办法可以解决呢？
很简单，把名称改成*就可以了。如下：
在这里插入图片描述这样的话，就导入了这个包里面的所有类。

【注意】
Java中包里面的类，是用到谁就调用谁，而不存在一下子把包里所有类都加载的情况。

3.JDK中常见的包

在JDK中，有各种实用的类，这些类按功能不同分别被放入了不同的包中，供开发者使用，常见的包如下：

  1. java.lang:系统常用基础类(String、Object、Math、System),此包从JDK1.1后自动导入，不需要用户手动导入。在java.lang包中还有一个子包：java.lang.reflect，用于实现java类的反射机制。
  2. java.net:进行网络编程开发包
  3. java.sql:进行数据库开发的支持包
  4. java.util:是java提供的工具程序包。(集合类等) 非常重要
  5. java.io:I/O编程开发包

4.包的访问控制权限

在Java中有4种访问控制权限，分别是private、default、protected、public。

1.private访问控制符

如果一个成员方法或成员变量名的前面使用了private访问控制符，那么这个成员只能在这个类的内部使用。

2.default默认访问控制符

如果一个成员方法或成员变量名的前面没有使用任何访问控制符，就称这个成员所拥有的是默认的（default）访问控制符。默认访问控制符成员可以被这个包中的其他类访问。如果一个子类与其父类位于不同包中，子类也不能访问父类种的默认访问控制成员。

3.protected访问控制符

如果一个成员方法或成员变量名的前面使用了protected访问控制符，那么这个成员既可以被包中的其他类访问，也可以被不同包中的子类访问。

4.public访问控制符

如果一个成员方法或成员变量名的前面使用了public访问控制符，那么这个成员可以被所有的类访问，不管访问类与被访问类是否在同一包中。

在这里插入图片描述

二、继承

1.继承的基本概念

按常理说，继承一般我们会想到继承家产，继承了家产，这个家产就属于你的啦。

在Java中继承也大概是这种意思：

通过继承简化类的定义，扩展类的功能，但是只能直接继承父类中的公有属性和公有方法（继承你父亲的财产），而隐含地（不可见地）继承了私有属性（继承你父亲的基因）。

实现继承的格式：

class 子类名 extends 父类

上面看完你可能会有点懵，不急，我们通过下面例子来讲解一下：

class Animal{
    public String name;//姓名
    public void eat(){//吃的方法
        System.out.println("Animal::eat()");
    }

    public void sleep(){//睡觉的方法
        System.out.println("Animal::sleep()");
    }

}
class Dog{
    public String name;//姓名
    public void eat(){//吃的方法
        System.out.println("Animal::eat()");
    }

    public void sleep(){//睡觉的方法
        System.out.println("Animal::sleep()");
    }
    public void run(){//跑步的方法
        System.out.println("Dog::run()");
    }
}

class Bird{
    public String name;//姓名
    public void eat(){//吃的方法
        System.out.println("Animal::eat()");
    }

    public void sleep(){//睡觉的方法
        System.out.println("Animal::sleep()");
    }
    public void fly(){//飞行的方法
        System.out.println("Bird::fly()");
    }
}

这个代码我们发现其中存在了大量的冗余代码。
仔细分析, 我们发现 Animal 和 Dog以及 Bird 这几个类中存在一定的关联关系：

  1. 这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
  2. 这三个类都具备一个相同的 name 属性, 而且意义是完全一样的
  3. 从逻辑上讲, Dog和 Bird 都是一种 Animal

此时我们就可以让 Dog和 Bird 分别继承 Animal 类, 来达到代码重用的效果。

此时, Animal 这样被继承的类, 我们称为 父类 、基类 或 超类, 对于像 Cat 和 Bird 这样的类, 我们称为子类、派生类。
在这里插入图片描述

和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果

在这里插入图片描述
那么继承之后，我们的代码就变成了下面这样了：

class Animal{
    public String name;//姓名
    public void eat(){//吃的方法
        System.out.println(this.name+"Animal::eat()");
    }
    public void sleep(){//睡觉的方法
        System.out.println("Animal::sleep()");
    }

}
class Dog extends Animal{
    public void run(){//跑步的方法
        System.out.println("Dog::run()");
    }
}

class Bird extends Animal{
    public void fly(){//飞行的方法
        System.out.println("Bird::fly()");
    }
}

这样一来，代码就简单多了。

Java继承时需要注意以下几点：

  1. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承），也就是说只能单继承，但是Java能多层继承，就是说A能继承B，B继承C，依次类推，但不宜超过3层继承。
  2. 子类会继承父类的所有 public 的字段和方法
  3. 对于父类的 private 的字段和方法, 子类中是无法访问的。也就是说，如果我们把上面例子中父类的name用private修饰，则无法访问，报错。
  4. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

2.继承时方法调用顺序

class Animal{
    public Animal(){//父类构造方法
        System.out.println("1.先输出");
    }
}
class Dog extends Animal{
    public Dog(){//子类构造方法
        System.out.println("2.后输出");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();

    }
}

在这里插入图片描述通过上面例子我们可以看出：

子类对象在实例化时会默认调用父类中的无参构造方法，之后再调用本类中的相应构造方法。

3.super和this关键字

super关键字出现在子类中，调用父类中的构造方法。

换句话来说，super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性和方法。

子类进行构造的时候，需要先帮助父类完成构造。

class Animal{
    public Animal(String name){//父类构造方法
        this.name=name;
    }
}
class Dog extends Animal{

    public Dog(String name){//子类构造方法
        super(name);//在这里用super调用父类中的构造方法
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog("haha");//在这里传name的值
    }
}

上述代码在子类的构造方法中，明确地指明了调用的是父类中有两个参数的构造方法。

super的用法：
super——代表父类对象的引用

  1. super.data(); //访问父类中的属性
  2. super.func（）；// 访问父类中的成员方法
  3. super（）； //调用父类的构造方法

this的用法之前文章提到过，this关键字详解，有兴趣可以去看看。

this——当前对象的引用

  1. this(); //调用本类其他构造方法
  2. this.data; //访问当前类中属性
  3. this.func(); //调用本类中的其他成员方法

4.final关键字

在Java中声明类、属性和方法时，可使用关键字final来修饰

  1. final标记的类不能被继承
  2. final标记的方法不能被子类覆写（密封方法）
  3. final标记的标量（成员或局部变量）即为常量，只能赋值一次。

1.final标记的变量只能赋值一次
在这里插入图片描述
2.final标记的类不能被继承实例
在这里插入图片描述3.final标记的方法不能被子类覆写
在这里插入图片描述

三、多态

1.向上转型

先把下面这句话读两三遍理解一下：

对象既可以作为它自己本身的类型使用，也可以作为它的基类型使用。而这种把对某个对象的引用视为对其基类型的引用的做法被称作为向上转型。

观察下面例子：

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Bird bird = new Bird("圆圆");//通过Bird实例化对象
        bird.fly();
    }
}

在这里插入图片描述什么时候会发生向上转型？（向上转型发生的时机）

  1. 直接赋值
  2. 方法传参
  3. 方法返回
class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ");
    }
}
public class TestDemo {
    //3.方法返回
    public static Animal func() {
        return new Bird("圆圆");
    }

    public static void main(String[] args) {
        Animal animal = func();
        animal.eat("虫子");
    }

    //2.方法传参
    public static void func(Animal bird) {
        bird.eat("虫子");
    }
    public static void main2(String[] args) {
        Bird bird = new Bird("圆圆");
        func(bird);
    }

    //1.直接赋值
    public static void main1(String[] args) {
        Animal bird = new Bird("圆圆");
        bird.eat("虫子");

    }
}

在这里插入图片描述【注意】

向上转型只能访问父类的方法和属性

2.动态绑定

当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢?


// Animal.java
class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println("我是一只小动物");
        System.out.println(this.name + "正在吃" + food);
    }
}
// Bird.java
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void eat(String food) {
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    }
}
// Test.java
public class TestDemo {
    public static void main(String[] args) {
        Animal animal1 = new Animal("圆圆");
        animal1.eat("谷子");
        Animal animal2 = new Bird("扁扁");
        animal2.eat("谷子");
    }
}

在这里插入图片描述【总结】

在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定。

3.方法重写

子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 覆写/重写/覆盖(Override)。

上面动态绑定的eat（）；方法就是重写。

我们以前学过重载，那么重写与重载有什么区别？

重写（override）：

  1. 方法名称相同
  2. 返回值相同
  3. 参数列表相同
  4. 不同的类体现在继承关系上

重载（overload）：

  1. 方法名相同
  2. 参数列表不同（参数的个数+类型）
  3. 返回值不作要求
  4. 在同一个类中

关于重写的注意事项：

  1. 需要重写的方法是不能被final修饰的。被final修饰之后，他是密封方法，不可以修改。
  2. 被重写的方法，访问修饰限定符一定不能是私有的
  3. 被重写的方法，子类当中的访问修饰限定要大于或等于父类的访问修饰符。（private<default<protected<public）
  4. 被static修饰的方法是不可以被重写的。

动态绑定和方法重写：

事实上, 方法重写是 Java 语法层次上的规则, 而动态绑定是方法重写这个语法规则的底层实现. 两者本质上描述的是相同的事情, 只是侧重点不同。

4.向下转型

向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象

// Animal.java
class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println("我是一只小动物");
        System.out.println(this.name + "正在吃" + food);
    }
}
// Bird.java
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void eat(String food) {
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    }

    public void fly() {
        System.out.println(this.name + "正在飞");
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Animal animal = new Bird("圆圆");
        bird.fly();
    }
}

在这里插入图片描述

对于 Animal animal = new Bird(“圆圆”) 这样的代码

  • 编译器检查有哪些方法存在, 看的是 Animal 这个类型
  • 执行时究竟执行父类的方法还是子类的方法, 看的是 Bird 这个类型

如果想实现fly（）方法的调用，则需要向下转型。

在这里插入图片描述【注意】
向下转型不安全，我们可以通过instanceof 判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。

在这里插入图片描述

5.理解多态

多态是一种思想

多态发生的前提：

  1. 父类引用，引用子类对象
  2. 父类和子类有同名的覆盖方法
  3. 通过父类引用调用这个重写的方法

使用多态的形式设计代码，我们可以写一些只关注父类的代码, 就能够同时兼容各种子类的情况。

class Shape{
    public void draw(){

    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("这是一个⚪");
    }
}

class React extends Shape{
    @Override
    public void draw() {
        System.out.println("这是一个□");
    }
}
public class TestDemo2 {

    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape1=new Cycle();
        Shape shape2=new React();//向上转型
        drawMap(shape1);
        drawMap(shape2);
    }
}

当类的调用者在编写 drawMap 这个方法的时候, 参数类型为 Shape (父类), 此时在该方法内部并不知道, 也不关注当前的 shape 引用指向的是哪个类型(哪个子类)的实例. 此时 shape 这个引用调用 draw 方法可能会有多种不同的表现(和对应的实例相关), 这种行为就称为多态。

使用多态的好处：

  1. 类调用者对类的使用成本进一步降低
    （1）封装是让类的调用者不需要知道类的实现细节.
    （2）多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可
  2. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
    （1） 圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很
    多的条件分支或者循环语句, 就认为理解起来更复杂.
    因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”.
  3. 可扩展能力更强
    （1）如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低

四、抽象类

如果一个方法没有具体实现，那么它就可以是一个抽象方法。

class Shape{
    public void draw(){

    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("这是一个⚪");
    }
}

class React extends Shape{
    @Override
    public void draw() {
        System.out.println("这是一个□");
    }
}
public class TestDemo2 {

    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape1=new Cycle();
        Shape shape2=new React();//向上转型
        drawMap(shape1);
        drawMap(shape2);
    }
}

在这里插入图片描述
父类可修改为：

abstract class Shape { 
 abstract public void draw(); 
}
  • 在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体
    代码
  • 对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类

【注意事项】

1.抽象类不能直接实例化

Shape shape = new Shape();// Shape是抽象的; 无法实例化,编译出错

2.抽象方法不能是 private 的

abstract class Shape { 
 abstract private void draw(); 
}
//非法的修饰符组合: abstract和private不能同时出现
  1. 抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用

抽象类的作用：

  1. 抽象类存在的最大意义就是为了被继承
  2. 抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法

五、接口

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

上面抽象类的代码，我们可以做一下对比：
在这里插入图片描述【注意事项】

  1. 使用 interface 定义一个接口
  2. 接口中的方法一定是抽象方法, 因此可以省略 abstract
  3. 接口中的方法一定是 public, 因此可以省略 public
  4. Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
  5. 在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例
  6. 接口不能单独被实例化
  7. 接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static)
interface IShape { 
 void draw(); 
 public static final int num = 10; 
 //其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量
}

六、抽象类与接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法,子类必须重写所有的抽象方法。

相同点：

  1. 都不能被实例化
  2. 接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。

不同点：

  1. 接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。
  2. 实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承
  3. 接口强调特定功能的实现，而抽象类强调所属关系。

最后

生命不息，奋斗不止。勤勤恳恳做事，堂堂正正做人！

十叶知秋
关注
  • 25
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
接口，多态，抽象类，final
08-10
在 Java 编程语言中，接口、多态、抽象类和 final 是四个非常重要的概念，它们在面向对象编程（Object-Oriented Programming，OOP）中扮演着关键角色。 1. 接口 接口是 Java 中的一种特殊的抽象类，所有方法都是...
Java中的接口和抽象类用法实例详解
09-03
总的来说，抽象类和接口都是Java中实现抽象和多态的重要工具，它们帮助开发者创建更加模块化、可扩展的代码结构，提高代码的重用性和维护性。在实际开发中，根据具体场景和需求，合理地运用抽象类和接口，可以提升...
详解python中的类、模块、包的概念和区别
最新发布
这家伙很懒，什么都没有留下
07-28 2624
在Python中，模块（Module）是一种组织代码的方式，用于将相关的代码封装在一个文件中，以便于代码的复用和管理。- 类的属性是属于类和其实例的变量，在类中定义，可以在类的任何方法中使用。- 例如，可以使用 `import module_name` 导入一个模块，然后通过 `module_name.function()` 的方式调用模块中的函数。- Python提供了一些内置模块，例如 `math`、`datetime` 等，这些模块提供了各种常用的功能和工具，可以直接导入和使用。
UML之包图
Java领域
06-25 4990
什么是包： 由包和包之间的关系构成。它是维护和控制系统总体结构的重要建模工具。在处理大量类、接口、组件、节点和图，有必要把这些元素进行分组，即：把那些语义相近并倾向于一个变化的元素组织起来加入同一包，这样方便理解和处理整个模型，同时也便于控制这些元素的可见性。设计良好的包是高内聚、低耦合，且对期内容的访问具有严密的控制。 包的名字（字符串）：简单名和路径名。简单名是指仅包含一个简单的名称。路径名是指以包位于的外围的名字作为前缀的包名。 包拥有那些元素？ 类、接口、组件、节点、协作、用例和图。还可
（精）Oracle包
08-26 7207
一、包的概念 PL/SQL为了满足程序模块化的需要，除了块(block)和子程序结构外，还引入了包的构造。 （1）包是一种数据库对象，将逻辑上相关的PL/SQL类型、对象和子程序组合成一个更大的单位，是一组相关过程、函数、变量、常量和游标等PL/SQL程序设计元素的组合，它具
Java的类(class)、包(package)和接口(interface)
cooljun618的专栏
09-23 6288
在Java中，类(class)是用来代表对象的基本单元。对象(object)可以是现实世界中的任何一个实体，它具有若干区别于其它对象的属性和操作。而类则通过为对象定义属性和操作来概括一类实体。它封装了一组变量和方法，是生成实例对象时的模板。如一辆汽车可视为一个对象，它既具有型号、
Java基础教程【第七章：包和接口】
振华OPPO的博客世界
02-26 467
Java 通过引入包的机制，来对这些类进行分门别类的管理。功能上有点类似于文件系统中的目录。
西南科技大学Java程序设计与实践 实验三 类的继承与多态的应用
06-14
西南科技大学Java程序设计与实践 实验三 类的继承与多态的应用 一、实验目的： 1、练习类的继承与多态设计过程； 2、练习面向对象的图形用户界面设计、事件设计方法。 二、实验内容： 1、利用多态性编程，创建一个 ...
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
Java实验报告——类的继承、多态的应用
02-21
1、实验名称：类的继承、多态的应用 2、代码内容：学生管理类 3、【实验目的】 （1）进一步熟悉抽象类和抽象方法的定义 （2） 进一步掌握集成和多态的实现方式。
Java的接口、内部类、常用类
12-22
【Java总结】-【入门篇(第四周)】 后续每周总结一次 JAVA接口、内部类、常用类 一、JAVA接口 1.1 什么是接口？: 接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:Java为单继承，当父类方法种类无法满足子类需求时，可实现接口扩充子类能力 接口支持多实现，可为类扩充多种接口 接口的格式 interface 接口名{ 静态常量 抽象方法 } 举个栗子: interface TestInterface{ public final static in
Java的继承、抽象类、接口、多态
Hrgge的博客
11-15 406
一，抽象方法将共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑无法在父类中具体明确地表示出来，该方法就可以定义为抽象方法。1.abstract不能与final并列修饰同一个类2.abstract不能与private， static， final或native并列修饰同一方法3.abstract方法必须位于abstract类中二，抽象类如果一个类中存在抽象方法，那么该类就必须声明为抽象类三，抽象类的注意事项1，抽象类不能实例化（不能创建对象 new）
java中常用的类，包，接口
weixin_34129696的博客
05-12 123
类 ObjectStringDateThread MathIntegerLongFile(java.lang.ThreadThread类的定义：public class Thread extends Object implements Runnable)===========================包java.lang.*;java.io.*;java.util.*;java....
Java中常用的类，包，接口
热门推荐
hongjie_lin
05-23 2万+
Java中常用的类，包，接口包名说明java.lang该包提供了Java编程的基础类，例如 Object、Math、String、StringBuffer、System、Thread等，不使用该包就很难编写Java代码了。java.util该包提供了包含集合框架、遗留的集合类、事件模型、日期和时间实施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。java.io该包通过文件系统...
java包和继承的区别,子类和父类在同一个包中继承性
weixin_30661579的博客
03-21 150
该楼层疑似违规已被系统折叠隐藏此楼查看此楼请问在同一个包中和在同一个源文件有什么区别？？？？？？以下子类和父类在同一个源文件中，如何保存为在同一个包中？class Father{ private int money;int weight;int getWeight(){return weight ;}protected void setWeight(int w){weight=w;}}cl...
java父包和子包_子类和父类在同一个包中继承性
weixin_36030121的博客
02-28 502
该楼层疑似违规已被系统折叠隐藏此楼查看此楼请问在同一个包中和在同一个源文件有什么区别？？？？？？以下子类和父类在同一个源文件中，如何保存为在同一个包中？class Father{ private int money;int weight;int getWeight(){return weight ;}protected void setWeight(int w){weight=w;}}cl...
JAVA中包、抽象类和接口
邱邱的博客
07-26 2257
1 包         大家能不能创建多个名称一样的类呢？当然是不可以的。但是包的出现，就解决了这个问题，包以分层方式保存并被明确的引入新的类定义，由此实现把类名空间划分为更多易管理的块的功能。包（package）是类的容器，用来保存划分的类名空间。例如，一个包允许你创建一个名为List的类，你可以把它保存在你自己的包中而不用考虑和其他地方的某个名为List的类相冲突。         这和W...
java中最常用的包和类（一）
qh老酸奶
09-11 2798
java中基本可重用类（一） 这次的笔记参考学校老师课件网上资料整理而得，若有遗漏或偏差，请各位大神批评指正，谢谢 这次博客主要介绍最常用的三个可重用包：java.lang和java.util。 一.  概论 java编程中需要用到一些最基本的类，这些类在java中以包结构来管理，下面我们看看最常用的几个包及其类。 上面这个树形图清晰的呈现了java中高度可重用类
Java自学笔记（二）Java的类、包和接口
人生就是为了樱岛麻衣的博客
03-12 682
文章目录2. Java的类、包和接口2.1 类、字段、方法2.1.1 类（class）2.1.2 字段（field）和方法（method）2.1.3 构造方法2.1.3 默认构造方法2.1.4 使用对象2.1.5 方法重载（overload）2.1.6 this的使用2.2 类的继承2.2.1 继承2.2.2 继承的好处2.2.3 派生子类2.2.4 继承关系2.2.5 字段2.2.6 方法2.3...
用JAVA语言编写一个图书销售系统平台要求使用对象和类继承多态抽象类接口数组集合
06-01
好的，我会尽力回答你的问题。 首先，我们需要定义一个Book类来表示每一本书，这个类需要包含以下属性：书名、作者、出版社、价格等。我们还需要定义一个BookStore类来表示整个图书店，这个类需要包含以下方法：添加图书、删除图书、查询图书、计算总销售额等。 接下来，我们需要定义一些子类来表示不同类型的书，比如小说、教育、历史等。这些子类需要继承自Book类，并且可以重写一些属性和方法。 我们还需要使用多态来实现一些特定的功能，比如计算不同类型书的销售额。我们可以定义一个抽象类或者接口来表示销售额计算器，并且让每个子类去实现它。 最后，我们需要使用数组和集合来存储图书信息和销售记录。比如我们可以使用一个Book数组来存储所有的书籍信息，使用一个ArrayList来存储每个订单的销售记录。 以上就是一个简单的图书销售系统平台的设计思路，当然具体实现还需要根据实际情况进行调整和完善。希望我的回答能够帮到你！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十叶知秋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值