【Java基础】

于 2024-09-08 18:01:13 发布
阅读量1.7k 收藏 27
点赞数 37
分类专栏： 学习系列 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44329069/article/details/142029774
版权

Java 基础

1. 变量与数据类型

在 Java 中，变量用于存储数据，每个变量都有类型。Java 的数据类型分为两类：

  • 基本数据类型（如 int, double, char, boolean）
  • 引用数据类型（如 String, 数组, 对象）

示例：

public class Main {
    public static void main(String[] args) {
        // 基本数据类型
        int age = 25;  // 整数类型
        double price = 19.99;  // 双精度浮点数类型
        char grade = 'A';  // 字符类型
        boolean isStudent = true;  // 布尔类型

        // 引用数据类型
        String name = "Alice";  // 字符串类型
        int[] scores = {90, 85, 88};  // 数组
    }
}

在这个例子中，age 是 int 类型的变量，price 是 double 类型的变量，name 是 String 类型的变量，scores 是一个整型数组。

2. 运算符与表达式

Java 提供了多种运算符，包括：

  • 算术运算符（如 +, -, *, /）
  • 关系运算符（如 ==, !=, <, >）
  • 逻辑运算符（如 &&, ||, !）

示例：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int sum = a + b;  // 加法运算符
        boolean isEqual = (a == b);  // 关系运算符：检查是否相等
        boolean isGreater = (a > b);  // 关系运算符：检查是否大于
        boolean result = (a > 5 && b < 30);  // 逻辑运算符 AND
        System.out.println("sum: " + sum);  // 输出：sum: 30
        System.out.println("isEqual: " + isEqual);  // 输出：isEqual: false
        System.out.println("result: " + result);  // 输出：result: true
    }
}

3. 控制流程

Java 提供多种控制流程语句来管理程序的执行顺序，常见的有：

  • if-else 语句
  • switch 语句
  • 循环（for, while, do-while）

示例：

public class Main {
    public static void main(String[] args) {
        int score = 85;

        // if-else 语句
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else {
            System.out.println("Grade: C");
        }

        // switch 语句
        char grade = 'B';
        switch (grade) {
            case 'A':
                System.out.println("Excellent");
                break;
            case 'B':
                System.out.println("Good");
                break;
            case 'C':
                System.out.println("Average");
                break;
            default:
                System.out.println("Invalid grade");
        }

        // for 循环
        for (int i = 0; i < 5; i++) {
            System.out.println("i: " + i);
        }

        // while 循环
        int count = 0;
        while (count < 3) {
            System.out.println("count: " + count);
            count++;
        }
    }
}

在上面的例子中，我们展示了 if-else，switch 以及 for 和 while 循环的使用。

4. 数组

数组是存储同一类型元素的集合。Java 中的数组是引用类型，支持各种基本数据类型和引用类型。

示例：

public class Main {
    public static void main(String[] args) {
        // 定义一个整型数组
        int[] numbers = {10, 20, 30, 40, 50};

        // 访问数组元素
        System.out.println("First element: " + numbers[0]);  // 输出：10

        // 修改数组元素
        numbers[1] = 25;
        System.out.println("Second element after update: " + numbers[1]);  // 输出：25

        // 遍历数组
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element at index " + i + ": " + numbers[i]);
        }
    }
}

这个例子展示了如何定义数组、访问和修改数组元素、以及遍历数组。

总结：

  • 变量与数据类型：Java 支持多种数据类型，基本类型包括 int，double，char 等，引用类型如 String 和数组。
  • 运算符与表达式：运算符用于操作变量和表达式，常见的有算术、关系和逻辑运算符。
  • 控制流程：通过 if-else，switch，循环等语句来控制程序的执行流程。
  • 数组：数组是存储相同类型元素的集合，可以通过索引访问或修改元素。

面向对象

面向对象编程（OOP）是 Java 编程的核心概念之一，包含对象与类、继承与多态、访问权限控制、接口等。

1. 对象与类

在 Java 中，类 是对象的蓝图，对象 是类的实例。类包含属性（字段）和行为（方法）。

示例：

// 定义一个类
class Person {
    // 属性（字段）
    String name;
    int age;

    // 构造方法（用于创建对象时初始化）
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法（行为）
    public void introduce() {
        System.out.println("Hi, my name is " + name + " and I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Bob", 30);

        // 调用方法
        person1.introduce();  // 输出：Hi, my name is Alice and I am 25 years old.
        person2.introduce();  // 输出：Hi, my name is Bob and I am 30 years old.
    }
}

在这个例子中，Person 是一个类，person1 和 person2 是它的对象。类中定义了属性（name 和 age）和方法（introduce）。

2. 继承与多态

继承 是指一个类可以继承另一个类的属性和方法。多态 允许子类根据自身需要重写父类的方法。

示例：

// 父类
class Animal {
    // 方法
    public void sound() {
        System.out.println("The animal makes a sound.");
    }
}

// 子类
class Dog extends Animal {
    // 重写父类的方法
    @Override
    public void sound() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建父类对象
        Animal myAnimal = new Animal();
        // 创建子类对象
        Dog myDog = new Dog();

        // 调用方法
        myAnimal.sound();  // 输出：The animal makes a sound.
        myDog.sound();     // 输出：The dog barks.

        // 多态：父类引用指向子类对象
        Animal anotherDog = new Dog();
        anotherDog.sound();  // 输出：The dog barks.
    }
}

在这个例子中，Dog 继承了 Animal，并重写了 sound() 方法。多态体现在父类引用（anotherDog）调用子类方法时依然调用了子类的实现。

3. 访问权限

Java 提供了四种访问修饰符来控制类、方法和属性的访问权限：

  • public：可以被任何类访问
  • private：只能在所属类内访问
  • protected：同包内以及子类可以访问
  • 默认（无修饰符）：同包内可访问

示例：

class Car {
    // public 变量可以从任何地方访问
    public String brand;

    // private 变量只能在类内部访问
    private int speed;

    // 构造方法
    public Car(String brand, int speed) {
        this.brand = brand;
        this.speed = speed;
    }

    // public 方法
    public void showDetails() {
        System.out.println("Brand: " + brand + ", Speed: " + speed);
    }

    // private 方法
    private void increaseSpeed() {
        speed += 10;
    }

    // 通过 public 方法访问 private 方法
    public void accelerate() {
        increaseSpeed();
        System.out.println("Speed after acceleration: " + speed);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", 100);

        car.showDetails();  // 输出：Brand: Toyota, Speed: 100
        car.accelerate();   // 输出：Speed after acceleration: 110

        // 无法直接访问 private 成员：car.speed = 120; (会报错)
    }
}

在这个例子中，speed 是 private 的，因此不能在 Main 类中直接访问，但我们可以通过 public 方法 accelerate() 来修改它。

4. 接口

接口 定义了一组方法，但不提供实现。类可以实现接口，并提供这些方法的具体实现。接口用于定义类的行为规范，并支持多重继承。

示例：

// 定义接口
interface Flyable {
    void fly();  // 抽象方法，没有实现
}

// 定义另一个接口
interface Swimmable {
    void swim();
}

// 类实现接口
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("The bird is flying.");
    }
}

// 类实现多个接口
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("The duck is flying.");
    }

    @Override
    public void swim() {
        System.out.println("The duck is swimming.");
    }
}

public class Main {
    public static void main(String[] args) {
        Flyable bird = new Bird();
        bird.fly();  // 输出：The bird is flying.

        Duck duck = new Duck();
        duck.fly();  // 输出：The duck is flying.
        duck.swim(); // 输出：The duck is swimming.
    }
}

在这个例子中，Flyable 和 Swimmable 是接口，Bird 类实现了 Flyable 接口，Duck 类实现了多个接口。通过接口，我们可以定义类的行为规范。

总结：

  • 对象与类：类是对象的蓝图，对象是类的实例，类包含属性和方法。
  • 继承与多态：子类可以继承父类的属性和方法，并通过多态实现不同的行为。
  • 访问权限：public、private、protected 控制类、方法、属性的访问权限。
  • 接口：接口定义行为规范，类可以实现接口并提供方法的具体实现。

常用类和集合

1. String 类

String 是 Java 中表示字符串的类。它是不可变的，这意味着一旦创建，字符串对象不能修改。

示例：

public class Main {
    public static void main(String[] args) {
        // 创建字符串
        String str1 = "Hello";
        String str2 = "World";

        // 字符串拼接
        String result = str1 + " " + str2;
        System.out.println(result);  // 输出：Hello World

        // 获取字符串长度
        System.out.println("Length: " + result.length());  // 输出：Length: 11

        // 获取字符
        System.out.println("Character at index 1: " + result.charAt(1));  // 输出：Character at index 1: e

        // 字符串比较
        System.out.println(str1.equals(str2));  // 输出：false

        // 字符串包含
        System.out.println(result.contains("Hello"));  // 输出：true

        // 转换大小写
        System.out.println(result.toUpperCase());  // 输出：HELLO WORLD
    }
}

在这个例子中，我们展示了 String 类的一些常用操作，如拼接、获取字符、比较、查找子字符串等。

2. Arrays 类

Arrays 是 Java 提供的用于操作数组的实用类，提供了很多静态方法用于排序、查找、填充等。

示例：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建数组
        int[] numbers = {5, 3, 8, 1, 2};

        // 数组排序
        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));  // 输出：Sorted array: [1, 2, 3, 5, 8]

        // 查找元素（需要排序后才能使用binarySearch）
        int index = Arrays.binarySearch(numbers, 3);
        System.out.println("Index of 3: " + index);  // 输出：Index of 3: 2

        // 填充数组
        int[] filledArray = new int[5];
        Arrays.fill(filledArray, 7);
        System.out.println("Filled array: " + Arrays.toString(filledArray));  // 输出：Filled array: [7, 7, 7, 7, 7]
    }
}

Arrays 类可以帮助我们进行数组的排序、查找元素、填充数组等操作。

3. Math 类

Math 类提供了一些数学函数和常量，如幂、平方根、三角函数等。

示例：

public class Main {
    public static void main(String[] args) {
        // 计算平方根
        System.out.println("Square root of 25: " + Math.sqrt(25));  // 输出：Square root of 25: 5.0

        // 计算次方
        System.out.println("2 raised to power 3: " + Math.pow(2, 3));  // 输出：2 raised to power 3: 8.0

        // 获取最大最小值
        System.out.println("Max of 10 and 20: " + Math.max(10, 20));  // 输出：Max of 10 and 20: 20
        System.out.println("Min of 10 and 20: " + Math.min(10, 20));  // 输出：Min of 10 and 20: 10

        // 生成随机数（0到1之间）
        System.out.println("Random number: " + Math.random());  // 输出：Random number: 0.XXX
    }
}

Math 类提供了许多静态方法用于数学运算，如平方根、次方、最大最小值和生成随机数。

4. Random 类

Random 类用于生成伪随机数，比 Math.random() 更强大。

示例：

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // 创建Random对象
        Random random = new Random();

        // 生成随机整数
        int randomInt = random.nextInt(100);  // 生成0到99之间的随机整数
        System.out.println("Random integer: " + randomInt);

        // 生成随机浮点数
        float randomFloat = random.nextFloat();  // 生成0到1之间的随机浮点数
        System.out.println("Random float: " + randomFloat);

        // 生成随机布尔值
        boolean randomBoolean = random.nextBoolean();
        System.out.println("Random boolean: " + randomBoolean);
    }
}

Random 类支持生成多种类型的随机值，如整数、浮点数和布尔值。

5. ArrayList 类

ArrayList 是动态数组，大小可动态增长。它属于 Java 集合框架的一部分。

示例：

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // 创建ArrayList
        ArrayList<String> names = new ArrayList<>();

        // 添加元素
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // 获取元素
        System.out.println("First name: " + names.get(0));  // 输出：First name: Alice

        // 遍历ArrayList
        for (String name : names) {
            System.out.println("Name: " + name);
        }

        // 删除元素
        names.remove("Bob");
        System.out.println("After removal: " + names);  // 输出：After removal: [Alice, Charlie]

        // 检查是否包含某个元素
        System.out.println("Contains Alice: " + names.contains("Alice"));  // 输出：Contains Alice: true

        // 获取大小
        System.out.println("Size: " + names.size());  // 输出：Size: 2
    }
}

ArrayList 提供了添加、删除、访问和遍历元素的方法，并且可以动态扩展数组大小。

6. HashMap 类

HashMap 是键值对（key-value）数据结构，允许快速查找、插入和删除操作。

示例：

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // 创建HashMap
        HashMap<String, Integer> ages = new HashMap<>();

        // 添加键值对
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 35);

        // 获取值
        System.out.println("Alice's age: " + ages.get("Alice"));  // 输出：Alice's age: 25

        // 检查是否包含某个键
        System.out.println("Contains key 'Bob': " + ages.containsKey("Bob"));  // 输出：Contains key 'Bob': true

        // 删除键值对
        ages.remove("Charlie");
        System.out.println("After removal: " + ages);  // 输出：After removal: {Alice=25, Bob=30}

        // 遍历HashMap
        for (String key : ages.keySet()) {
            System.out.println(key + ": " + ages.get(key));
        }

        // 获取大小
        System.out.println("Size: " + ages.size());  // 输出：Size: 2
    }
}

HashMap 可以通过键来快速查找对应的值，并且支持高效的添加、删除、和遍历操作。

总结：

  • String：不可变的字符串类，支持字符串操作。
  • Arrays：提供数组操作的实用类，包括排序、查找、填充等。
  • Math：包含常用数学运算方法。
  • Random：用于生成伪随机数。
  • ArrayList：动态数组，支持自动调整大小。
  • HashMap：键值对数据结构，用于高效查找和存储数据。
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java输入只有一行_即三个整数_中间用空格隔开_蓝桥杯 算法训练 排序
weixin_30863333的博客
02-28 6418
 问题描述 　　编写一个程序，读入一组整数，这组整数是按照从小到大的顺序排列的，它们的个数N也是由用户输入的，最多不会超过20。然后程序将对这个数组进行统计，把出现次数最多的那个数组元素值打印出来。如果有两个元素值出现的次数相同，即并列第一，问题描述 　　编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。输入格式：输入只有一行，即三个整数，中间用空格隔开。输出格式：输出只有...
java一行输入多个数据用空格隔开
qq_63917380的博客
01-15 6667
Java一行输入多个数据，用空格隔开。
java读取一行带有间隔的整数，并将它们存储在数组中
最新发布
weixin_43489984的博客
06-20 772
请注意，上述代码假设输入的整数之间使用空格作为间隔符。如果使用其他分隔符，例如逗号或分号，你需要将line.split(" ")中的空格替换为相应的分隔符。运行该代码后，程序将提示你输入一行带有间隔的整数。例如，你可以输入1 2 3 4 5，然后程序将把这些整数存储在数组中，并打印出数组中的整数。在Java中，你可以使用Scanner类来读取一行带有间隔的整数，并将它们存储在数组中。
java 输入一组整数用空格隔开，进行升降序排列输出，结尾无空格。
m0_61152671的博客
12-18 3630
import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String []strarr=in.nextLine().split(" “); int []arr=new int[strarr.length]; int i=0; for(i=0;i<arr.length
java基础：输入一串数字，用空格隔开，输出存在两次的数字
leiyuqian1010的博客
09-15 1万+
之前困扰在如何能把一串数字的个数得到，还在想如何能将每一个数字统一放入一个数组中。（拖延症晚期） 这次，果真就碰到了题目，悔，来记录一下吧。   看到可以将输入的用String来接收，之后用空格隔开，放入一数组number中。 ps：不要小瞧那些看起来不起眼的方法，还是记住一些吧。 Scanner in = new Scanner(System.in); String stri...
Java读取一行空格隔开的数字字符串并求出这些数字的和方法
08-27
今天小编就为大家分享一篇Java读取一行空格隔开的数字字符串并求出这些数字的和方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
《Java基础案例教程（第2版）》课后习题答案1
08-08
【Java基础知识点】 1. **Java的起源与特性** - Java是由SUN Microsystems公司（后被Oracle收购）开发的一种面向对象的编程语言。 - Java有三个主要版本：Java Standard Edition (JavaSE)，用于桌面应用；Java ...
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始学习的JAVA基础到高级学习教程，对于有JAVA基础的同学来说可以略过前面的JAVA基础章节，直接学习后续的JAVA高级部分课程。更可以灵活的作为章节技术，进行针对性的JAVA学习。还是要...
Java 基础入门（传智播客出品）.pdf
03-01
Java 基础入门，适合初学入门java的同学
Java 输入一行以空格分隔字符作为输入数据转存为数组形式并输出
kimiszc的博客
10-29 9769
用java写一些算法题目的时候需要输入一些数据，像C或者CPP都可以有专用的输入函数进行输入，在Java里需要稍微麻烦一些，具体代码如下： import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner in = new Scanner(Syste...
java输入多个数据_Java中怎么读入一行输入空格隔开的多个数据
weixin_32546235的博客
02-12 6580
展开全部import java.util.Scanner;public classReadData{public static void main(String[] args) {ReadData r=new ReadData();Scanner input=new Scanner(System.in);//Scanner input=new Scanner("abc 123 bbss");S...
Java中Object转化为int类型
weixin_43369038的博客
12-07 1万+
Java中Object转化为int类型  Java中由Object类型转化为int类型时，不能直接转化，先是将Object类型转化成String类型，然后将String类型转化为int类型！ Object object=null; Integer.parseInt(String.valueOf(object)); 这就是将Object类型转化为int类型，而String.valueOf(v...
java将Object数组转换为指定类型数组
热门推荐
zhangbeizhen18的博客
01-17 3万+
场景:     将Object数组转换为指定类型数组 1.转换函数 public static &lt;T&gt; T[] convertArray(Class&lt;T&gt; targetType, Object[] arrayObjects) { if (targetType == null) { return (T[]) arrayObject...
Java读取一行空格隔开的数字字符串并求出这些数字的和
华love邵的博客
05-25 1万+
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); while(in.hasNextLine())//判断是否有输入一行数据 { String tmp = in.nextLine
输入一行整数，整数之间用空格隔开，读取并计算它们的和。
sinat_37372543的博客
06-19 1万+
代码摘自刘汝佳 算法竞赛入门经典 int main() { string line; while (getline(cin, line)) { int sum = 0, x; stringstream ss(line); while (ss >> x) { sum += x; } ...
全面掌握Java基础知识要点
以上便是Java基础知识点的概述，对于初学者而言，理解和掌握这些知识点是学习Java的第一步。通过实践操作，不断编写代码和调试程序，可以逐渐加深对Java语言的理解和应用。同时，这些基础知识点也为后续深入学习Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值