【JAVA】十三、基础知识“接口”精细讲解！(二)(新手友好版~)

最新推荐文章于 2025-05-16 10:30:01 发布
最新推荐文章于 2025-05-16 10:30:01 发布
阅读量1.7k 收藏 37
点赞数 58
分类专栏： 【JAVA】 文章标签： java 接口 interface 抽象类和接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_88761930/article/details/147407095
版权

        哈喽大家好呀qvq，这里是乎里陈，接口这一知识点博主分为三篇博客为大家进行讲解，今天为大家讲解第二篇java中实现多个接口，接口间的继承，抽象类和接口的区别知识点，更适合新手宝宝们阅读~更多内容持续更新中~

目录

1. 实现多个接口

完整代码讲解

 2. 接口间的继承

完整代码讲解

3. 抽象类和接口的区别

定义方式上不同

继承/实现方式不同

区别表格

1. 实现多个接口

        在Java中，接口（Interface）定义了一组抽象方法，用于规范类的行为。类和类之间是单继承的，一个类只能由一个父类，即java不支持类的多重继承，但是一个类可以实现多个接口，从而扩展类的功能；这种机制使得Java可以实现类似多重继承的效果。

        比如说：

  • 一个 Bird 类可以同时实现 Flyable 和 Run 这两个接口。

  • 一个 Smartphone 类可以同时实现 Callable（可打电话），Playable（可播放音乐）和 Photographable（可拍照）三个接口。

        像这样实现多个接口的话，我们可以更灵活地设计程序，避免单继承的限制，可以让类具备更多的功能~

首先，我们初步定义了一个狗狗类🐶继承动物类：

//建立一个动物抽象类：
//1.用abstract修饰，表示这是一个抽象类，不能直接创建实例
//2.包含了所有动物共有的属性和方法
public abstract class Animal {
    //公共属性名字和年龄（所有动物和植物都有的）
    public String name;
    public int age;
    //抽象方法：吃东西
    //1.用abstract修饰，没有具体的实现
    //2.所有的子类必须实现这个方法
    public abstract void eat();
    //动物类的构造方法
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
}
//定义了一个狗狗类
//1.继承自动物类（extends Animal）
//2.必须实现父类的抽象方法eat()
public class Dog extends Animal{
    //狗狗的构造方法
    public Dog(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override//表示重写
    public void eat() {
        System.out.println(name+"吃狗粮啦~");
    }
}

        写完上面代码后，我们知道狗狗不仅会游泳，也会跑步，则可以让这个狗狗类实现游泳接口和跑步接口（前提是定义了游泳和跑步的接口）：

 定义的三个接口，狗狗只能实现里面的两个：

public interface Flyable {
    void fly();
}
public interface Running {
    void run();
}
public interface Swimming {
    void swim();
}

  • extends Animal 表示继承Animal类

  • implements Running, Swimming 表示实现两个接口，后面可通过逗号再添加几个狗狗能实现的接口

// Dog通过extends继承Animal并且通过implemens实现了Running和Swimming接口
public class Dog extends Animal implements Running,Swimming{
    ...
}

在实现接口后，我们必须还要实现Running和Swimming接口里面的方法：

// Dog通过extends继承Animal并且通过implemens实现了Running和Swimming接口
public class Dog extends Animal implements Running,Swimming{
    //狗狗的构造方法
    public Dog(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override//表示重写
    public void eat() {
        System.out.println(name+"吃狗粮啦~");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"正在飞跑~");
    }
    //实现Swimming接口的swim()方法
    @Override
    public void swim() {
        System.out.println(name+"正在狗刨~");
    }
}

        所以通过上面的代码我们实现了Dog类继承Animal类，然后通过implements实现了Running和Swimming两个接口，我们要注意一定是先继承再实现接口，如果把extends放后面是会产生错误的啦：

同样的，我们知道java中一个类只能继承一个类，若是再继承一个也会产生错误啦：

        那么我们说过解决多继承的问题，到底是怎么体现的呢？我们往下看，不妨假设一下，没有Running和Swimming这两个接口，而是Running和Swimming两个类，然后Dog再继承它们：

        很显然是不行的啦~怎么可以继承多个类呢，所以我们就需要接口，可以将我们这些规则的行为放到我们接口当中，这样就能解决多继承。很明显不是所有的动物都会飞，如果我们将Flyable放到我们Animal类里面，很明显是不合适的，狗狗是不会飞的。

        我们再定义一个鸟类继承父类Animal并通过implements实现Running和Flyable接口来观察：

// Bird通过extends继承Animal并且通过implemens实现了Running和Flyable接口
public class Bird extends Animal implements Running,Flyable{
    //小鸟儿的构造方法
    public Bird(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override
    public void eat() {
        System.out.println(name+"吃鸟粮");
    }
    //实现Flyable接口的fly()方法
    @Override
    public void fly() {
        System.out.println(name+"正在酷酷飞翔");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"奋力疾走中");
    }
}

        很明显小鸟只能飞和跑，并不能游泳，所以鸟类只能实现Running和Flyable接口，不能实现Swimming接口~

🟢那么我们写下测试类：

public class Test2 {
    //测试方法1 - 接收Animal类型参数;animal可以是Animal类或其任何子类的对象
    public static void test1(Animal animal) {
        // 调用动物的eat方法，具体执行哪个看实际传入对象类型
        // 例如：test1(new Dog()) 会调用Dog类的eat()
        // test1(new Cat()) 会调用Cat类的eat()
        animal.eat();
    }
    //测试方法2 - 接收Running接口类型参数
    //是任何实现了Running接口的对象
    public static void test2(Running running) {
        //调用传入对象的run()方法
        //只要对象实现了Running接口就能传入，不管它是什么具体类
        running.run();
    }
    //测试方法3 - 接收Swimming接口类型参数
    //是任何实现了Swimming接口的对象
    public static void test3(Swimming swimming) {
        //调用传入对象的swim()方法
        //可以接收任何"会游泳"的对象
        swimming.swim();
    }
    //测试方法4 - 接收Flyable接口类型参数
    //是任何实现了Flyable接口的对象
    public static void test4(Flyable flyable) {
        //调用传入对象的fly()方法
        //可以接收任何"会飞"的对象
        flyable.fly();
    }
    //第一个测试主方法 - 演示接口多态
    public static void main1(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test2方法 - 传入会跑步的对象
        test2(bird);// 让鸟儿跑步(Bird实现了Running接口)
        test2(dog);// 让狗狗跑步(Dog实现了Running接口)
        System.out.println("----------------");// 分隔线
        // 测试test3方法 - 传入会游泳的对象
        test3(dog);// 让狗狗游泳(Dog实现了Swimming接口)
        //⚠️不可以test3(bird);Bird没有实现Swimming接口
        System.out.println("----------------");// 分隔线
        // 测试test4方法 - 传入会飞的对象
        test4(bird);// 让鸟儿飞翔(Bird实现了Flyable接口)
        //⚠️不可以test4(dog);Dog没有实现Flyable接口
    }
    //第二个测试主方法 - 演示继承多态
    public static void main2(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test1方法 - 传入动物对象
        test1(bird);// 让鸟儿吃东西(调用Bird的eat方法)
        test1(dog);// 让狗狗吃东西(调用Dog的eat方法)
        // 这里因为Bird和Dog都是Animal的子类，所以都可以传入啦
    }
}

🌟 我们可以从上述代码得出以下的一些个人理解：

1. 多态是什么？

  • 就像同一个"动作"在不同对象上有不同表现
  • 例如：同样是"吃"，鸟吃鸟粮，狗吃狗粮

2. 接口多态（main1演示）

  • test2( )中可以接受任何会跑步的对象（实现了Running接口就可以）

  • 不管传入的是鸟还是狗，只要会跑步就行

3. 继承多态（main2演示）

  • test1( )可以接受任何动物对象（是Animal的子类）

  • 不管传入的是鸟还是狗，因为它们都是动物

4. 那么为什么这样设计呢？

  • 能提高代码灵活性：不需要为每种动物写单独的方法

  • 便于扩展：新增一些动物类型的时候不需要修改测试方法

⚠️还是再提一下：每个测试方法(test1-test4)的行为取决于：实际传入的对象类型，该对象对应方法的实现方式~

完整代码讲解

下面是完整版本的代码：附带超详细注释，更适合新手宝宝们阅读~

// 1. 首先定义接口
public interface Flyable {
    void fly();
}
public interface Running {
    void run();
}
public interface Swimming {
    void swim();
}

// 2. 定义抽象父类
//建立一个动物抽象类：
//1.用abstract修饰，表示这是一个抽象类，不能直接创建实例
//2.包含了所有动物共有的属性和方法
public abstract class Animal {
    //公共属性名字和年龄（所有动物和植物都有的）
    public String name;
    public int age;
    //抽象方法：吃东西
    //1.用abstract修饰，没有具体的实现
    //2.所有的子类必须实现这个方法
    public abstract void eat();
    //动物类的构造方法
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
}

// 3. 定义具体实现类
// Bird通过extends继承Animal并且通过implemens实现了Running和Flyable接口
public class Bird extends Animal implements Running,Flyable{
    //小鸟儿的构造方法
    public Bird(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override
    public void eat() {
        System.out.println(name+"吃鸟粮");
    }
    //实现Flyable接口的fly()方法
    @Override
    public void fly() {
        System.out.println(name+"正在酷酷飞翔");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"奋力疾走中");
    }
}

// Dog通过extends继承Animal并且通过implemens实现了Running和Swimming接口
public class Dog extends Animal implements Running,Swimming{
    //狗狗的构造方法
    public Dog(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override//表示重写
    public void eat() {
        System.out.println(name+"吃狗粮啦~");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"正在飞跑~");
    }
    //实现Swimming接口的swim()方法
    @Override
    public void swim() {
        System.out.println(name+"正在狗刨~");
    }
}

// 4. 定义测试类
public class Test2 {
    //测试方法1 - 接收Animal类型参数;animal可以是Animal类或其任何子类的对象
    public static void test1(Animal animal) {
        // 调用动物的eat方法，具体执行哪个看实际传入对象类型
        // 例如：test1(new Dog()) 会调用Dog类的eat()
        // test1(new Cat()) 会调用Cat类的eat()
        animal.eat();
    }
    //测试方法2 - 接收Running接口类型参数
    //是任何实现了Running接口的对象
    public static void test2(Running running) {
        //调用传入对象的run()方法
        //只要对象实现了Running接口就能传入，不管它是什么具体类
        running.run();
    }
    //测试方法3 - 接收Swimming接口类型参数
    //是任何实现了Swimming接口的对象
    public static void test3(Swimming swimming) {
        //调用传入对象的swim()方法
        //可以接收任何"会游泳"的对象
        swimming.swim();
    }
    //测试方法4 - 接收Flyable接口类型参数
    //是任何实现了Flyable接口的对象
    public static void test4(Flyable flyable) {
        //调用传入对象的fly()方法
        //可以接收任何"会飞"的对象
        flyable.fly();
    }
    //第一个测试主方法 - 演示接口多态
    public static void main1(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test2方法 - 传入会跑步的对象
        test2(bird);// 让鸟儿跑步(Bird实现了Running接口)
        test2(dog);// 让狗狗跑步(Dog实现了Running接口)
        System.out.println("----------------");// 分隔线
        // 测试test3方法 - 传入会游泳的对象
        test3(dog);// 让狗狗游泳(Dog实现了Swimming接口)
        //不可以test3(bird);Bird没有实现Swimming接口
        System.out.println("----------------");// 分隔线
        // 测试test4方法 - 传入会飞的对象
        test4(bird);// 让鸟儿飞翔(Bird实现了Flyable接口)
        //不可以test4(dog);Dog没有实现Flyable接口
    }
    //第二个测试主方法 - 演示继承多态
    public static void main2(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test1方法 - 传入动物对象
        test1(bird);// 让鸟儿吃东西(调用Bird的eat方法)
        test1(dog);// 让狗狗吃东西(调用Dog的eat方法)
        // 这里因为Bird和Dog都是Animal的子类，所以都可以传入啦
    }
}

最后的输出结果为：

愤怒的小鸟儿奋力疾走中  
开心的小狗狗正在飞跑~
----------------
开心的小狗狗正在狗刨~
----------------
愤怒的小鸟儿正在酷酷飞翔

 最后总结一下：

        上述代码展示了一个类继承一个父类，同时实现多种接口。继承表达的含义是 is-a，而接口表达的含义是具有某某特性。

 2. 接口间的继承

        想象你正在设计一个动物园管理系统。最初，你定义了Swimming（可游泳）和Flyable（可飞行）两个基础接口。但随着系统发展，你发现有些鸟类既会飞又会潜水（比如企鹅）。这时候，就需要用到接口间的继承啦~重新定义一个接口，这个接口具备Swimming和Flyable这两个接口的功能，让这个新的接口继承Swimming接口和Flyable接口~

例如我们先定义三个接口：

//分别定义了两个个接口
//并分别定义了各自的抽象方法
interface A {
    void testA();
}
interface B {
    void testB();
}

这时候我们想要有一个接口，拥有A和B这两个接口的功能，则这样实现：

//有一个接口，具备A和C接口的功能，extends为扩展
interface C extends A,B {
    //C这个接口具备了B和C的功能,同时也有自己的抽象方法
    void testC();
}

那么当一个类实现我们C接口，需要重写A,B,C里的三个方法：

public class Test4 implements C{

    @Override
    public void testA() {
        
    }
    @Override
    public void testB() {

    }
    @Override
    public void testC() {

    }
}

完整代码讲解

实现接口间继承示例完整的代码如下：

//分别定义了三个接口
//并分别定义了各自的抽象方法
interface A {
    void testA();
}
interface B {
    void testB();
}
//有一个接口，具备A和C接口的功能，extends为扩展
interface C extends A,B {
    //C这个接口具备了B和C的功能,同时也有自己的抽象方法
    void testC();
}
//实现子接口的类必须实现所有继承链上的抽象方法
public class Test4 implements C{

    @Override
    public void testA() {

    }
    @Override
    public void testB() {

    }
    @Override
    public void testC() {

    }
}

        接口C通过extends关键字继承了接口A和B，通过上述代码我们可以总结出接口继承的特点：

  • 一个接口(C)可以继承多个父接口(A,B)
  • 子接口(C)可以继承所有父接口(A,B)的抽象方法
  • 子接口可以定义自己的新方法
  • 接口间的继承相当于把多个接口合并在一起

3. 抽象类和接口的区别

🔴java中抽象类和接口的区别，这是常见的面试题

抽象类和接口都是 Java 中多态的常见使用方式，我们需要知道：

"抽象类管是什么，接口管能做什么"

抽象类关注类的本质，接口关注行为扩展。

定义方式上不同

// 抽象类 - 用abstract修饰
abstract class Animal {
    // 可以有具体属性
    String name;
    int age;
    
    // 可以有具体方法
    public void sleep() {
        System.out.println("动物在睡觉");
    }
    
    // 可以有抽象方法
    public abstract void eat(); 
}

// 接口 - 用interface修饰
interface Swimmable {
    // 只能有常量（默认是public static final）
    int a = 5;
    
    // 只能有抽象方法（Java8前）
    void swim();
}

继承/实现方式不同

// 类继承抽象类（extends）
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃狗粮");
    }
}

// 类实现接口（implements）
class Fish implements Swimmable {
    @Override
    public void swim() {
        System.out.println("鱼在游泳");
    }
}

区别表格

特性抽象类接口
关键字abstract classinterface
子类继承/实现使用extends关键字继承抽象类（单继承）使用implements关键字实现接口（多实现）
构造方法有无
结构组成普通类+抽象方法抽象方法+全局变量
设计理念"是什么"（is-a关系）"能做什么"（has-a能力）
适用场景有共同特征的类

定义类的行为规范

关系一个抽象类可以实现多个接口

接口不能继承抽象类，

但是可以使用extends继承多个父接口

那么我们该选择哪个使用，可以根据以下内容选择：

1. 用抽象类当：

  • 多个类有共同属性和方法时
  • 需要定义一些默认实现时
  • 例子：不同种类的鸟都有羽毛，都会飞，但飞行方式不同

2. 用接口当：

  • 只想定义行为规范时
  • 需要类具备多种能力时
  • 例子：鸭子既能游泳(Swimming)又跑(Running）

💡总结一下：

        抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用(不必重写)。

       而接口中，不能包含普通方法，子类必须重写所有的抽象方法。比如此处的 Animal 中包含一个 name 这样的属性，这个属性在任何子类中都是存在的。因此此处的 Animal 只能作为一个抽象类，而不应该成为一个接口。

class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
 }

在这其中，也经常会有这些面试题： 

  • 一个类能同时继承类和实现接口吗？

✅ 可以的，先extends类后implements接口

  • 接口能继承类吗？

❌ 不能的，接口只能继承接口

制作不易，更多内容加载中~感谢友友们的点赞收藏关注~~

如有问题欢迎批评指正，祝友友们生活愉快，学习工作顺顺利利！

万字长文讲解团队使用Spark中选型，使用Scala、Java还是Python？
大模型大数据攻城狮的专栏
10-01 246
化为具体的任务并分发到各个Executor上执行。而Executor则是实际执行计算任务的进程，负责数据的计算和存储。这种架构使得Spark能够高效地处理大规模数据，并支持多种编程语言和数据处理模型，为数据科学家和工程师提供了极大的灵活性。在Spark的架构中，还有一个重要的概念是集群管理器（Cluster Manager），它负责集群资源的分配和管理。Spark可以与多种集群管理器集成，如Apache Mesos、Hadoop YARN等，这使得Spark能够轻松地在各种环境中部署和运行。
01Java入门篇（D1_Java入门前的认知）
思维码途
08-08 1313
编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到相应结果的过程。编程就是写那些指令的过程，我们使用一种编程语言来实现这些指令的编写，这些指令被翻译成计算机能够读懂的格式，最后由计算机执行指令。计算机编程语言包括C语言、C++语言 Java语言、Python语言、数据库开发语言、其他编程语言。计算机编程语言是程序设计的最重要的工具，它是指计算机能够接受和处理的、具有一定语法规则的语言。很多人觉得编程是门高深莫测的学问, 担心自己学不来。
【JAVA】十三、基础知识“接口”精细讲解！(三)(新手友好版~)
Practice makes perfect
05-08 1797
精心讲解java多态中Object，toString，equals，hashCode，comparable，Clonable接口，深拷贝浅拷贝等等的知识点，小白也能看懂，进行了超详细描述，有例子说明，代码理解，画图记忆，方便刚学的友友们学习~想明白java中接口知识点看这一篇文章就够了~
【JAVA】十三、基础知识“接口”精细讲解！(一)(新手友好版~)
Practice makes perfect
04-22 1197
精心讲解java多态中接口的基本概念，接口的语法格式，接口的详细使用规则等等的知识点，小白也能看懂，进行了超详细描述，有例子说明，代码理解，画图记忆，方便刚学的友友们学习~想初步明白java中接口基本知识的友友们看这一篇文章就够了~
Java 大视界 -- Java 大数据云原生应用开发：容器化与无服务器计算（十三）
【青云交】华为云云享专家，在技术圈个人影响力位居前 17，跻身博客之星 TOP23。全国原力、全网领军人物双料登顶，作者周榜位居前二，苏州地区各榜也统统拿下榜首之位，实力爆棚！
01-06 1606
本文围绕《Java 大视界 -- Java 大数据云原生应用开发：容器化与无服务器计算（十三）》展开，开篇承前启后引入，详述云原生崛起、核心要素，深入讲解容器化（Docker、Kubernetes）与无服务器计算（AWS Lambda）实战，剖析优势挑战，展望未来，结合案例、代码助力从业者掌握前沿技术。
Java~学习简单了解GC中常见的垃圾回收器
2401_83916204的博客
05-04 771
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
知识付费创业中的用户分层运营策略
AI天才研究院
11-23 632
第一部分：核心概念与联系 在知识付费创业中，用户分层运营策略是一种重要的市场细分方法。它旨在通过将用户根据不同的特征划分为多个层次，从而实现更精准、高效的运营和营销。下面，我们将详细探讨这一策略的基本概念和架构，并通过一个Mermaid流程图展示其核心组成部分。 1.1 知识付费创业
Netty快速入门
Zhangsama1的博客
04-23 8630
Netty快速入门
Java集合方面的面试题大汇总
2401_84048034的博客
05-05 692
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java Swing 第三版 英文
01-10
### Java Swing 第三版 关键知识点概述 #### 一、Swing 概述与特性 - **Swing 定义**：Swing 是一个用于开发 Java 应用程序用户界面的开发工具包，它建立在抽象窗口工具包（AWT）的基础上，允许开发者创建具有可...
【SpringBlade开发手册入门指南】：新手必备基础知识
[【SpringBlade开发手册入门指南】：新手必备基础知识](https://media.geeksforgeeks.org/wp-content/uploads/20190501124658/setting1.png) # 摘要 本文旨在全面介绍SpringBlade框架，一个高效的企业级应用开发...
SoftUni基础课程：Java编程入门指南
资源摘要信息: "SoftUni基础知识课程是一门为初学者设计的Java编程入门课程。本课程内容涵盖了编程基础中的基础概念、条件语句、循环控制结构以及基本的操作。它非常适合编程新手，特别是没有任何编程背景的新手，...
Java TCP/IP套接字编程指南：从基础到进阶
这本书适合有一定Java基础的开发者，无论你是希望学习套接字编程的新手，还是想要深入了解Java网络编程的中级或高级开发人员，都能从中找到所需的知识和实践案例。通过阅读和实践这些章节，读者可以掌握如何在Java中...
Java 多线程应用循环输出ABC
26857259
05-14 243
Java 多线程应用循环输出ABC
Android App CAN通信测试
最新发布
tianpu2320959696的博客
05-16 495
CAN总线协议（Controller Area Network）， 控制器局域网总线，是德国BOSCH（博世）公司研发的一种串行通讯协议总线， 它可以使用双绞线来传输信号，是世界上应用最广泛的现场总线之一。
HashSet
weixin_51718998的博客
05-15 780
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
Java零基础学习Day12——集合ArrayList
m0_68932052的博客
05-13 657
集合只存引用数据类型；长度可变数组可存基本数据类型、引用数据类型；长度固定。
安装Hadoop并运行WordCount程序
2401_84653595的博客
05-12 1091
安装hadoop时，它自带了很多的示例代码，其中有一个是用来统计词频的程序，下面我们来看一下如何去运行这个示例代码。在任意目录下，运行 java -version，如果能看到以下结果，则代表Java安装成功。使用cd命令进入到opt/software目录，再使用ls命令，查看是否已经上传成功。使用的命令是： vi /etc/profile.d/my_env.sh。（1）新建/etc/profile.d/my_env.sh文件。打开/etc/profile.d/my_env.sh文件。注意，后面我们会按照。
SQLServer如何为数据库创建只读账号，并测试是否只读成功。直接代入替换就行，全流程，新手替换复制即可。
weixin_44858074的博客
05-14 222
本文详细介绍了如何在 SQL Server 中为数据库 SQL_Xxxx 创建一个名为 zhidu_os 的只读账号，并将其密码设置为 SQL_Passwd
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值