java基础知识点-阿里云开发者社区

Java是一种面向对象的编程语言，广泛应用于各种平台和领域。下面将介绍一些Java基础知识点。

1. 数据类型：

基本数据类型：byte、short、int、long、float、double、char、boolean。
引用数据类型：类(class)、接口(interface)、数组(array)。
基本数据类型：

byte myByte = 10;
short myShort = 100;
int myInt = 1000;
long myLong = 10000L;
float myFloat = 3.14f;
double myDouble = 3.14159;
char myChar = 'A';
boolean myBoolean = true;

引用数据类型：

String myString = "Hello World";
int[] myArray = {1, 2, 3, 4, 5};
List<Integer> myList = new ArrayList<>();

2. 变量和常量：

变量是程序中用于存储数据的容器，可以改变其值。
常量是一旦定义就不能改变其值的量。

int myVariable = 10; // 变量
final int myConstant = 100; // 常量

3. 运算符：

算术运算符：+、-、*、/、%。
关系运算符：==、!=、>、<、>=、<=。
逻辑运算符：&&、||、!。
赋值运算符：=、+=、-=、*=、/=、%=。
其他运算符：三元运算符(?😃、位运算符(&、|、^、~、<<、>>、>>>)

int a = 10;
int b = 5;
int sum = a + b; // 加法
int difference = a - b; // 减法
int product = a * b; // 乘法
int quotient = a / b; // 除法
int remainder = a % b; // 取余
boolean isEqual = (a == b); // 相等判断
boolean isGreater = (a > b); // 大于判断
boolean isLess = (a < b); // 小于判断
boolean logicalAnd = (a > 0) && (b > 0); // 逻辑与
boolean logicalOr = (a > 0) || (b > 0); // 逻辑或
int result = (a > b) ? a : b; // 三元运算符

4. 控制流程：

条件语句：if-else、switch-case。
循环语句：for、while、do-while。
分支语句：break、continue、return。

条件语句：if-else

int age = 18;
if (age >= 18) {
    System.out.println("成年人");
} else {
    System.out.println("未成年人");
}

循环语句：for

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

分支语句：break、continue、return

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 跳出循环
    }
    if (i == 3) {
        continue; // 跳过当前循环
    }
    System.out.println(i);
}
public int sum(int a, int b) {
    return a + b; // 返回结果并结束方法
}

5. 数组：

数组是一组相同数据类型的元素的集合。
数组可以是一维的、二维的，甚至是多维的。
数组的长度是固定的，一旦创建就不能改变。

int[] numbers = new int[5]; // 声明一个大小为5的整型数组
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
System.out.println(numbers[2]); // 输出3
String[] names = {"Alice", "Bob", "Charlie"}; // 声明并初始化一个字符串数组
System.out.println(names.length); // 输出3，数组长度

6. 类和对象：

类是用于创建对象的模板，包含属性（字段）和方法。
对象是类的实例，可以通过new关键字创建。
类和对象的关系是一种抽象和具体的关系。

public class Person {
    // 属性
    private String name;
    private int age;
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old.");
    }
}
Person person = new Person("Alice", 20); // 创建Person对象
person.sayHello(); // 调用对象的方法

7. 方法：

方法是一段可重用的代码块，用于完成特定的功能。
方法可以有参数和返回值。
方法可以被其他方法调用，从而实现代码的模块化和复用。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result = calculator.add(3, 4); // 调用方法
        System.out.println(result); // 输出7
    }
}

8. 继承：

继承是面向对象编程中的重要概念，用于实现类之间的关系。
通过继承，一个类可以继承另一个类的属性和方法。
继承可以实现代码的重用和扩展。

public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}
public class Cat extends Animal {
    public void meow() {
        System.out.println("Meow!");
    }
}
Cat cat = new Cat();
cat.eat(); // 继承父类的方法
cat.meow(); // 子类自己的方法

9. 接口：

接口是一种规范，用于定义类应该具有的方法。
类可以实现一个或多个接口，从而实现多态性。
接口可以实现代码的解耦和灵活性。

public interface Flyable {
    void fly();
}
public class Bird implements Flyable {
    public void fly() {
        System.out.println("Bird is flying.");
    }
}
Bird bird = new Bird();
bird.fly(); // 实现接口的方法

10. 异常处理：

- 异常是程序运行时发生的错误或异常情况。
- 异常处理可以通过try-catch-finally块来实现。
- 异常可以分为受检异常和非受检异常。

try {
    int result = 10 / 0; // 发生异常
    System.out.println(result);
} catch (ArithmeticException e) {
    System.out.println("除数不能为0");
} finally {
    System.out.println("无论是否发生异常，都会执行finally块");
}

11. 文件操作：

- Java提供了File类和相关的IO类来进行文件的读写操作。
- 通过File类可以创建、删除、重命名文件和目录。
- 通过IO类可以实现文件的读取和写入。

import java.io.*;
public class FileOperations {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try {
            FileWriter writer = new FileWriter(file);
            writer.write("Hello, World!");
            writer.close();
            FileReader reader = new FileReader(file);
            BufferedReader bufferedReader = new BufferedReader(reader);
            String line = bufferedReader.readLine();
            System.out.println(line);
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

12. 多线程：

- 多线程是同时执行多个任务的机制。
- Java提供了Thread类和Runnable接口来实现多线程。
- 多线程可以提高程序的效率和响应能力。

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}
public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

练习题：

编写一个程序，求解两个整数的和，并输出结果。

编写一个程序，输入一个年龄，判断是否为成年人（大于等于18岁），如果是则输出"成年人"，否则输出"未成年人"。

编写一个程序，使用循环输出1到10的所有偶数。

编写一个程序，声明一个大小为5的整型数组，然后使用循环输入数组中的元素值，并计算数组中所有元素的和。

声明一个名为"Person"的类，包含私有属性：姓名和年龄，以及一个公有的无参构造方法和一个公有的带参构造方法。再在该类中声明一个公有的方法"sayHello"，用于输出"Hello, my name is [姓名] and I’m [年龄] years old."。然后创建一个Person对象并调用sayHello方法。

编写一个计算器类"Calculator"，包含一个公有的"add"方法，用于计算两个整数的和，并返回结果。然后在主方法中创建一个Calculator对象，调用add方法计算3和4的和，并输出结果。

声明一个"Animal"类，其中包含一个公有的"eat"方法，用于输出"Animal is eating.“。再声明一个"Cat"类继承自Animal类，并添加一个公有的"meow"方法，用于输出"Meow!”。在主方法中创建一个Cat对象，分别调用eat和meow方法。

声明一个"Flyable"接口，包含一个无参的公有"fly"方法。然后创建一个"Bird"类实现"Flyable"接口，并在"fly"方法中输出"Bird is flying."。最后创建一个Bird对象，调用fly方法。

编写一个程序，使用try-catch-finally语句，将两个整数相除，并处理除数为0的异常。

编写一个程序，将一段文本写入文件，并读取该文件的内容并输出。

编写一个程序，创建一个继承自Thread类的子类，重写run方法，在run方法中输出"Thread is running."，然后创建并启动该子线程。

这些练习题可以帮助你巩固和实践上述知识点，希望对你有帮助！

以上是一些Java基础知识点的简要介绍，它们是Java编程的基本要素。在实际开发中，我们需要深入理解这些知识点，并灵活运用它们来解决问题。同时，还可以通过学习其他高级的Java知识点，如集合框架、反射机制、注解等，来进一步提升Java编程能力。

java基础知识点