【Java学习】Java基础知识和核心概念

已于 2024-09-26 18:14:41 修改
阅读量878 收藏 12
点赞数 12
文章标签： java 学习 开发语言
于 2024-09-20 15:13:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75208773/article/details/142355678
版权

一、Java概述

1.Java是什么？

Java是一门面向对象的编程语言，作为静态面向对象编程语言的代表，很好地实现了面向对象的各种特性，如封装、继承、多态等，能够以简洁、优雅的方式处理复杂的编程问题。不仅如此，Java还是一个完整的技术体系，涵盖了从开发工具、编译器、虚拟机到应用运行环境的一整套技术支持。Java不仅在传统软件开发领域占据重要地位，还广泛应用于嵌入式系统、移动开发、企业级应用等多个行业，是一门非常优秀的编程语言。

2.Java的发展史

Java的前身是Oak，由詹姆斯·高斯林（James Gosling）于1991年在Sun Microsystems（后来被甲骨文公司收购）开发。起初，Oak是为了开发一种能够运行在多种设备上的程序，特别是家用电子设备和嵌入式系统。然而，随着互联网的兴起，Oak项目被重新定位为一种面向网络的编程语言，并在1995年正式更名为Java。

1995年5月，Java 1.0正式发布，这标志着Java语言及其平台的正式诞生。Java 1.0引入了Java平台的核心特性，包括Java虚拟机（JVM）、Java编程语言、Java API等。Java的设计初衷是“一次编写，到处运行”（Write Once, Run Anywhere, WORA），这一理念极大地推动了Java的普及和应用。

3.Java的特点

  • 面向对象：Java是纯粹的面向对象编程语言，几乎所有内容都以对象和类的形式存在。面向对象的特性包括封装、继承、多态，使得代码更易于维护、扩展和复用。

  • 跨平台性：Java的跨平台能力源自其在不同系统上运行的Java虚拟机（JVM）。Java代码被编译为字节码（bytecode），然后通过JVM在不同的平台上运行，而无需重新编译代码。

  • 安全性：Java设计之初就特别注重安全性。它提供了多层次的安全机制，允许开发人员创建健壮的、抵御潜在攻击的应用程序。尤其是在网络传输、远程操作等应用场景中，Java的安全机制得到了广泛使用。

  • 垃圾回收机制：Java具有自动的垃圾回收系统（Garbage Collection, GC），它能够帮助开发者管理内存，减少手动处理内存泄漏和指针操作带来的复杂性。

  • 丰富的类库和API：Java提供了丰富的标准类库，包括用于数据结构、I/O操作、网络编程、多线程、GUI等方面的API。这些类库极大地提升了开发效率，简化了许多常见功能的实现。

  • 多线程支持：Java内置对多线程的支持，能够轻松处理并发任务。开发者可以使用线程管理并发任务，提高程序的响应速度和处理能力。

  • 广泛应用领域：Java不仅被用于桌面应用和Web开发，还广泛应用于移动应用（Android使用Java作为主要开发语言之一）、企业级系统开发、大数据处理（如Hadoop）和物联网（IoT）。

二、Java基本语法

1.注释

  • 单行注释

  • 多行注释

  • 文档注释（Javadoc注释）

2.关键字

3.标识符

  • 命名规则

1.标识符可以包含字母、数字、下划线（_）、美元符号（$），但不能包含其他符号如@、#等。

2.不能以数字开头。

3.不能是Java的关键字

4.区分大小写

  • 命名惯例（见名知意）

1.变量和方法名通常使用小驼峰命名法，即第一个单词小写，后续单词的首字母大写。

2.类和接口名通常使用大驼峰命名法，即每个单词的第一个字母大写

3.常量名通常所有字母大写，并用下划线（_）分隔单词

4.包名通常采用小写字母，如果包名较长，可以用点号（.）分隔

4.变量

  • 变量的声明

        数据类型 变量名 = 数据值;

        数据类型：限定了变量能存储数据的类型 int(整数）double(小数)

        变量名：就是存储空间的名字，方便以后使用

        =：赋值，把右边的数据赋值给左边的变量

        数据值：真正存在变量中的数据

  • 基本数据类型      

        1.整数类型:byte, short, int, long

                整数默认为int型，long声明须后加'l'或'L'

        2.浮点类型:float, double

                浮点数默认为double型，float声明须后加'f'或'F'

        3.字符类型:char

                2字节

        4.布尔类型:boolean

                不可用0和非0的整数数代替true和flase

  • 基本数据类型转换

  1. 自动类型转换（隐式转换）：容量小的类型自动转换位容量大的数据类型。
  2. 强制类型转换（显式转换）：将容量大的数据类型转换为容量小的数据类型。

        使用时要加上强制转换符：(<数据类型>)，但可能造成精度降低或溢出, 格外要注意。

5.运算符

  • 算术运算符

  • 赋值运算符

  • 关系运算符

用于比较两个值，返回布尔值（true或false）

  • 逻辑运算符

  • 位运算符

  • 三目运算符

        条件表达式 ? 表达式1 : 表达式2

       如果条件为true，则返回表达式1的结果；如果条件为false，则返回表达式2的结果。

6.程序流程结构

  • 选择结构（分支结构）

if-else结构

switch-case结构

 switch-case语句执行时会先进行匹配，匹配成功返回当前case的值，再根据是否有 break，判断是继续输出或是跳出判断。

  • 循环结构

for循环

执行顺序：初始化部分→判断循环条件→循环体→迭代更新变量值→判断循环条件→循环体→……→直到不满足循环条件时循环终止。

while循环

执行顺序与for循环一样

while循环与for循环的区别：

1.for循环适用于已知循环次数或需要通过计数器控制循环的情况。

2.while循环适用于当循环次数不确定，或者条件变化较为复杂的情况。

do-while循环

执行顺序：初始化部分→循环体→迭代更新变量值→判断循环条件→循环体→……→直到不满足循环条件时循环终止。

do-while循环与while循环的区别：

1.while循环在每次循环开始之前检查条件表达式。

2.do-while循环在每次循环开始之前先执行一次循环体，然后检查条件表达式。

  • 跳转结构

break：跳出当前循环或switch语句。

continue：跳过当前循环的剩余部分，直接进入下一次循环。

return：退出当前方法，返回到调用者。

三、基础类库

1.字符串

  • 创建

  • 常用方法

  • StringBilder和StringBuffer

StringBuilder和StringBuffer是可变字符串类，即它们可以在现有的字符串基础上进行修改，而不创建新的对象。

常用方法

区别：

2.数组

  • 一维数组

        声明： 数据类型[ ]  数组名;

        初始化

        静态初始化

        

        动态初始化

        

        访问:通过索引访问数组中的元素，索引从0开始。

        长度:数组的长度通过.length属性获取。

        遍历:可以使用for循环或增强型for循环来遍历数组。

  • 多维数组

        声明: 数据类型[ ][ ]  数组名;

        初始化

        静态初始化

        

        动态初始化

        

  • 数组使用异常

        数组越界:访问数组时，如果索引超出数组的范围，会抛出 ArrayIndexOutOfBoundsException异常。

        

        空指针异常 :访问或者操作一个一个为null的数组时，会抛出NullPointerException异常。

        

3.集合

  • 概述

集合（Collections）是用于存储和操作一组数据的框架。Java 提供了多种集合类来存储和操作对象，它们位于java.util包中。集合框架提供了一套标准的接口和类，可以轻松操作数据，并解决常见的编程需求。

  •  Collection接口

Collection是所有集合类的根接口，派生了以下子接口：

List是一种有序的集合，允许包含重复的元素。

Set是一种无序的集合，不允许有重复元素。

Queue是一种遵循先进先出(FIFO)原则的集合

  • Map接口

Map 是用于存储键值对的数据结构。

  • Iterator 接口

Iterator 提供遍历集合的方式，Iterator 适用于 Collection 的所有子类

  • 遍历

1. 使用 Iterator 遍历

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

2. 使用增强型 for 循环遍历

for (String s : list) {
    System.out.println(s);
}

  • 集合和数组的区别

使用数组：当知道数据的大小是固定的，且需要频繁通过索引进行访问时

使用集合：当需要灵活地增加、删除或操作数据，或者处理不同类型的复杂数据结构时

四、面向对象

1.类和对象

  • 类

类是对一类事物的描述，是抽象的，概念上的定义。

基本组成部分：

  • 属性：类中定义的变量，描述对象的特征。
  • 行为：类中的方法，定义对象的功能和行为。
  • 构造方法：用于初始化对象的特殊方法。
  • 静态成员：使用 static 修饰的变量或方法，属于类本身，而不属于某个对象。

 定义

class ClassName {
    // 属性
    String name;
    int age;
    // 构造方法
    ClassName(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 方法（行为）
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

  • 对象

对象是根据类创建的实例，是实际存在的事物个体。

创建对象：

  1. 定义类：首先要有一个类作为对象的模板。
  2. 实例化对象：使用new关键字调用类的构造方法来创建对象。
  3. 访问对象的属性和方法：通过对象可以访问类中的属性和方法。
public class Main {
    public static void main(String[] args) {
        // 创建对象
        ClassName person = new ClassName("Alice", 25); // 使用类 ClassName 实例化对象
        // 访问对象的属性和方法
        person.displayInfo();  // 调用对象的方法
    }
}

  •  类和对象的关系

  1. 类是模板，对象是类的实例。
  2. 类定义了对象的属性和行为，对象通过实例化类来实现这些属性和行为。
  3. 多个对象可以通过同一个类创建，每个对象有自己独立的属性，但它们共享相同的行为（方法）。

2.方法

  • 定义

        

       修饰符（可选）：public、private、static等。

       返回类型：方法返回的值的类型。如果方法不返回值，使用void。

       方法名：方法的名称，遵循Java 的标识符命名规则。

       参数列表：方法接受的参数，可以为空。如果有多个参数，用逗号分隔。

       方法体：包含方法的具体代码。

       返回值：通过 return 语句返回方法的计算结果，如果返回类型为 void，则可以省略 return。

  • 类型

1. 无返回值的无参方法

public void greet() {
    System.out.println("Hello, World!");
}

2. 有参无返回值的方法

public void printMessage(String message) {
    System.out.println(message);
}

3. 有参有返回值的方法

public int add(int a, int b) {
    return a + b;
}

4. 静态方法：使用static关键字修饰的方法

public static int add(int a, int b) {
    return a + b;
}

  • 调用

在同一个类中调用：在同一个类中，方法之间的调用是非常简单的。既可以直接调用静态方法，也可以直接调用非静态方法。

public class Example {
    // 定义一个静态方法
    public static void method1() {
        System.out.println("This is method1");
    }
    // 定义一个非静态方法
    public void method2() {
        System.out.println("This is method2");
        method3();  // 非静态方法可以直接调用非静态方法
    }
    // 另一个非静态方法
    public void method3() {
        System.out.println("This is method3");
        method1();  // 非静态方法可以直接调用静态方法
    }
    public static void main(String[] args) {
        method1();   // 静态方法可以直接调用静态方法
        // method2();   静态方法不能直接调用非静态方法
        Example example = new Example();
        example.method2();  // 通过对象调用非静态方法
    }
}

为什么静态方法不能直接调用非静态方法？

  • 静态方法属于类本身，在没有对象的情况下也可以通过类名调用。
  • 非静态方法属于对象，它需要依赖具体的对象实例才能调用。
  • 静态方法不包含对象的上下文(即没有 this 引用)，因此不能访问或操作与对象相关的非静态成员。

从另一个类调用：

调用静态方法:静态方法属于类本身，而不是对象。调用静态方法时，不需要创建对象，只需通过类名调用。

public class ClassA {
    // 静态方法
    public static void staticMethod() {
        System.out.println("ClassA");
    }
}

public class ClassB {
    public static void main(String[] args) {
        ClassA.staticMethod();  // 直接通过类名调用 ClassA 中的静态方法
    }
}

调用非静态方法:非静态方法属于对象，因此在不同类中调用非静态方法时，需要先创建该类的对象。

public class ClassA {
    // 非静态方法
    public void displayMessage() {
        System.out.println("ClassA");
    }
}

public class ClassB {
    public static void main(String[] args) {
        ClassA classA = new ClassA();  // 创建 ClassA 的对象
        classA.displayMessage();  // 调用 ClassA 中的非静态方法
    }
}

  • 方法重载

        在同一类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。

public class OverloadingExample {
    // 方法重载
    public void print(int num) {
        System.out.println("Number: " + num);
    }

    public void print(String message) {
        System.out.println("Message: " + message);
    }

    public void print(int num, String message) {
        System.out.println("Number: " + num + ", Message: " + message);
    }

    public static void main(String[] args) {
        OverloadingExample example = new OverloadingExample();
        example.print(5);               // 输出: Number: 5
        example.print("Hello");         // 输出: Message: Hello
        example.print(10, "Java");      // 输出: Number: 10, Message: Java
    }
}

  • 参数传递

对于基本数据类型：采用值传递机制。如果参数是基本数据类型，传递的是真实的数据，形参的改变，不影响实参的值。

对于引用数据类型：如果参数是引用数据类型，传递的是地址值，形参的改变，影响实参的值

3.构造方法

构造方法（Constructor） 是一种特殊的方法，用于在创建对象时初始化对象的状态。

  • 特点

1.没有返回类型：构造方法没有返回类型，甚至不能写 void。

2.与类名相同：构造方法的名字必须和类名完全相同。

3.自动调用：构造方法在使用new关键字创建对象时自动调用。

4.可以重载：一个类可以有多个构造方法，称为构造方法的重载，它们通过不同的参数列表来区

  • 类型

1. 无参构造方法（默认构造方法）

如果一个类没有定义任何构造方法，Java 会自动提供一个无参构造方法，也称为默认构造方法。如果定义了其他构造方法，那么 Java 将不再提供默认的无参构造方法，开发者需要自己定义。

public class Person {
    String name;
    int age;
    
    // 无参构造方法
    public Person() {
        this.name = "Madalie";
        this.age = 18;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();  // 调用无参构造方法
        System.out.println(person.name);  // 输出: Madalie
        System.out.println(person.age);   // 输出: 18
    }
}

2. 有参构造方法

有参构造方法允许在创建对象时直接给对象的属性赋值，通过传递参数来初始化对象的状态。可以根据需要定义多个有参构造方法。

public class Person {
    String name;
    int age;
    
    // 有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Mdalie", 18);  // 调用有参构造方法
        System.out.println(person.name);  // 输出: Madalie
        System.out.println(person.age);   // 输出: 18
    }
}

  • 重载

在一个类中可以定义多个构造方法，参数列表不同，称为构造方法重载。根据传入参数的不同，Java 会自动选择合适的构造方法。

public class Person {
    String name;
    int age;
    
    // 无参构造方法
    public Person() {
        this.name = "Madalie";
        this.age = 18;
    }
    
    // 有参构造方法
    public Person(String name) {
        this.name = name;
        this.age = 22;
    }

    // 有参构造方法重载
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();  // 调用无参构造方法
        Person p2 = new Person("Bob");  // 调用单参数构造方法
        Person p3 = new Person("Charlie", 25);  // 调用双参数构造方法

        System.out.println(p1.name + ", " + p1.age);  // 输出: Madalie, 18
        System.out.println(p2.name + ", " + p2.age);  // 输出: Bob, 22
        System.out.println(p3.name + ", " + p3.age);  // 输出: Charlie, 25
    }
}

4.封装

  • 权限修饰符

  • 特点

  1. 私有化属性：类的属性通常设置为private，即该属性只能在类的内部被访问，外部类不能直接修改或读取。
  2. 公开访问方法：通过public修饰的getter和setter方法提供了对私有属性的间接访问，外部类通过这些方法来操作对象的状态。
  3. 数据校验：在setter方法中，可以添加逻辑来检查赋值是否符合预期，从而提高数据的安全性。

  • 作用

  1. 信息隐藏：通过将类的属性设为私有，外部无法直接访问，只有通过类提供的公共方法才能操作这些属性。
  2. 提高代码的可维护性：外界通过特定的方法访问对象的属性，方法中可以控制逻辑和验证，从而保护数据的安全。
  3. 灵活性和可扩展性：类可以改变内部实现而不影响外部代码，只需保持公共接口不变即可。
  4. 控制权限：封装可以通过访问修饰符（private、protected、public）控制类成员的访问权限。

实现步骤

  1. 将类的属性声明为私有（private），防止外部类直接访问。
  2. 提供公共的getter和setter方法，用于对私有属性进行读写操作。
  3. 在getter和setter中可以添加数据校验逻辑，从而控制属性的合法性。
public class User {
    // 私有属性
    private String name;
    private int age;
    // 构造方法
    public User(String name, int age) {
        this.name = name;
        setAge(age);  // 调用 setter 方法进行验证
    }
    // 公共的 getter 方法，用于获取 name
    public String getName() {
        return name;
    }
    // 公共的 setter 方法，用于设置 name
    public void setName(String name) {
        this.name = name;
    }
    // 公共的 getter 方法，用于获取 age
    public int getAge() {
        return age;
    }
    // 公共的 setter 方法，用于设置 age
    public void setAge(int age) {
        if (age > 0 && age < 100) {// 在 setter 中添加数据校验逻辑
            this.age = age;
        } else {
            System.out.println("数据无效，请重新输入！");
        }
    }
}

5.继承

允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。

  • 基本概念

  1. 父类（基类 / 超类，Superclass）：被继承的类，父类包含子类可以复用的属性和方法。
  2. 子类（派生类，Subclass）：继承父类的类，子类不仅继承了父类的成员，还可以添加新的成员或重写父类的方法。

  • 特点

  1. 单继承：在 Java 中，一个类只能有一个直接的父类，不能同时继承多个类。Java 通过接口（interface）来实现多重继承的功能。
  2. super  关键字：用于调用父类的构造方法或访问父类的方法和属性。子类可以使用super  关键字访问父类的成员。
  3. 子类拥有父类的属性和方法：子类可以直接使用父类的公共和受保护成员。
  4. 子类可以扩展或重写父类：子类可以添加新的方法和属性，也可以重写父类的方法，实现多态性。

  • 作用

  1. 代码复用：子类继承了父类的代码，避免重复编写相同的逻辑。
  2. 提高代码可维护性：修改父类的代码，所有子类都会受益，统一管理和更新。
  3. 提高扩展性：子类可以在父类的基础上进行扩展或重写功能，适应不同的需求。

  • 实现

  1. 定义父类，包含基本属性和方法。
  2. 定义子类，使用extends关键字。
  3. 创建子类对象，可以访问父类方法。
  4. 重写父类方法，如需要自定义行为。
  5. 使用 super关键字，调用父类方法或构造器。
class Animal {
    // 父类的属性
    String name;
    // 父类的构造方法
    public Animal(String name) {
        this.name = name;
    }
    // 父类的方法
    public void makeSound() {
        System.out.println(name + "在叫");
    }
}

class Dog extends Animal {
    // 子类的构造方法
    public Dog(String name) {
        super(name);  // 使用 super 调用父类构造方法
    }
    // 子类重写父类的方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪汪");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建父类对象
        Animal animal = new Animal("动物");
        animal.makeSound();  // 调用父类方法
        // 创建子类对象
        Dog dog = new Dog("百万");
        dog.makeSound();  // 调用重写后的子类方法
    }
}

  • 方法重写

方法重写是指子类提供了对父类方法的新的实现，用于替换父类的方法。重写时，方法名、参数列表和返回类型必须与父类的方法一致。

 @Override注解：Java 提供了 @Override注解来标识方法重写，这不仅能提高代码的可读性，还能让编译器帮助检查是否真正覆盖了父类的方法。

class Animal {
    public void makeSound() {
        System.out.println("动物叫");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

  • Object类

 Object类是所有类的父类。也就是说，每个类默认都继承自 Object类（即使没有显式声明）。

常用方法

6.多态

多态是指同一操作可以作用于不同类型的对象上，主要通过方法重载和方法重写实现。

类型

1. 方法重载（编译时多态）

方法重载是指同一个类中多个方法具有相同的名称，但参数类型或数量不同。编译器根据参数的类型和数量来决定调用哪个方法。

class MathUtil {
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

2. 方法重写（运行时多态）

方法重写是指子类重新定义父类的方法。运行时多态允许通过父类引用指向子类对象，从而调用子类重写的方法。

class Animal {
    void sound() {
        System.out.println("动物叫");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("汪汪汪");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("喵喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 父类引用指向子类对象
        Animal myCat = new Cat();

        myDog.sound(); // 输出: 汪汪汪
        myCat.sound(); // 输出: 喵喵喵
    }
}

  • 注意

  1. 多态只能通过继承或接口实现。
  2. 父类引用指向子类对象时，调用的方法是根据实际对象的类型来决定的，而不是根据引用的类型。

7.抽象类

抽象类是 Java 中的一种特殊类，用于定义一组方法的模板，但不提供这些方法的具体实现。抽象类通常用于为子类提供基本的框架，子类可以继承抽象类并实现具体的方法。

  • 定义

使用abstract关键字定义抽象类。

abstract class Animal {
    // 抽象方法
    public abstract void makeSound();
    // 非抽象方法
    public void eat() {
        System.out.println("吃东西");
    }
}

  • 实现

子类继承抽象类并实现其抽象方法

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

  • 调用

通过子类实例化并调用方法

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound();  // 输出 "汪汪汪"
        myDog.eat();        // 输出 "吃东西"

        Animal myCat = new Cat();
        myCat.makeSound();  // 输出 "喵喵喵"
        myCat.eat();        // 输出 "吃东西"
    }
}

特点

  1. 抽象类不能被实例化，必须通过子类来实例化。
  2. 抽象类可以有构造方法，供子类调用。
  3. 抽象类可以包含实例变量和方法（抽象方法和非抽象方法）。
  4. 子类必须实现抽象方法，如果子类不实现所有抽象方法，子类也必须声明为抽象类。

  • 抽象方法

抽象方法是在抽象类中使用abstract关键字定义，只有方法的声明，没有方法体的方法。

  • 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法；

8.接口

 接口（Interface）是一种特殊的引用类型，用于定义类的行为规范。接口只包含方法的声明，而不包含方法的实现。

  • 定义

使用interface关键字来定义

interface Animal {
    void makeSound();  // 抽象方法
    default void eat() {  // 默认方法
        System.out.println("吃东西");
    }
}

实现

实现一个接口，类必须使用implements关键字，并提供接口中所有方法的实现。

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

  • 调用

一旦类实现了接口，就可以创建对象并调用接口中定义的方法。

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 使用接口类型引用
        myDog.makeSound();  // 输出 "汪汪汪"
        myDog.eat();        // 输出 "吃东西"

        Animal myCat = new Cat();
        myCat.makeSound();  // 输出 "喵喵喵"
        myCat.eat();        // 输出 "吃东西"
    }
}

  • 特点

  1. 方法声明：接口只能包含方法的声明（默认是public abstract），不包含具体实现。Java 8 及以后，接口可以包含默认方法（使用default关键字）和静态方法。

  2. 常量：接口中定义的变量都是public static final 类型，即常量。

  3. 多重继承：一个类可以实现多个接口，解决了 Java 的单继承限制。

  4. 实现：实现接口的类必须实现接口中的所有方法，除非该类是抽象类。

  5. 不能包含构造方法：接口不能有构造方法，因此不能实例化接口。

  • 抽象类和接口的区别

Madalie
关注
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java高频面试基础知识点整理
热门推荐
张彦峰的博客
11-04 167万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
史上最强 Java 学习路线图！
沉默王二
04-24 28万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
Java基础知识面试题（2020最新版）
ThinkWon的博客
02-19 131万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
java基础知识点
学Java，找哪吒
09-18 2万+
🏆作者简介：哪吒，CSDN2022博客之星Top1、CSDN2021博客之星Top2、多届新星计划导师✌、博客专家💪，专注Java硬核干货分享，立志做到Java赛道全网Top N。🏆本文收录于，，目前已经700+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。🏆姐妹篇，，包含面向对象、基本数据类型、数组、继承和多态、泛型、枚举等Java基础知识点。🏆姐妹进阶篇，
java核心技术卷1基础知识整理
qq_39748316的博客
02-23 4485
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Java基础知识点总结
是阿超
09-25 6354
Java基础知识点总结
Java学习路线（完整详细版）超详细
曾昭武
05-14 25万+
一门永不过时的编程语言——Java 软件开发。 Java编程语言占比： 据官方数据统计，在全球编程语言工程师的数量上，Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程，因此其程序员的数量最多。而在以Java编程为核心的开发领域中，javaEE程序员的需求量10年来一直居于首位！ Java工程师就业： 1.通过各大招聘网站统计，全国海量公司都在招聘J...
Java 基础核心总结
分享是一种积极的生活态度~~
05-17 1283
Java 是一种广泛使用的程序设计语言，具有跨平台、面向对象、安全性高、灵活性强等特点，广泛应用于企业级应用程序和移动应用程序等领域。在学习 Java 语言时，需要掌握一些基础核心知识，本文将为您总结 Java 基础核心知识点，以便于您的学习和参考。介绍Java 基础核心知识点包括基本语法、面向对象编程、异常处理、集合框架、IO 流和多线程等方面。
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
( Java核心技术 卷1 基础知识 原书第9版.zip ) PDF 高清版
04-20
《Java核心技术 卷1 基础知识 原书第9版》是Java开发者必读的经典之作，它深入浅出地介绍了Java编程语言的核心概念和技术。这本书的PDF高清版为学习者提供了清晰易读的阅读体验，方便深入理解每个知识点。 首先，...
JAVA核心技术基础知识配套源代码
06-29
"JAVA核心技术基础知识配套源代码"提供了学习Java编程的基础实例，帮助初学者从零开始构建自己的Java知识体系。这个资源包的核心内容围绕Java的核心概念，包括但不限于类与对象、封装、继承、多态、异常处理、集合...
Java核心技术卷一基础知识第10版
09-05
第10版根据Java SE 8全面更新，同时修正了第9版中的不足，系统全面讲解了Java语言的核心概念、语法、重要特性和开发方法，包含大量案例，实践性强。 　本书共14章。第1章概述Java语言与其他程序设计语言不同的性能；...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 78
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 513
Java StreamAPI的使用与常用方法
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 788
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 210
BI商业智能：数据可视化、报表可视化系统。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 701
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值