JavaSE初阶重难点知识梳理~~~
1.基础语法
目录
1.基础语法
A.数据结构：数据类型分为引用数据类型和基本数据类型
基本数据类型分为4类：
整数类型：
浮点类型
字符类型
引用数据类型：包括类，接口，数组等
变量：是存储数据的容器（先声明再使用）
B.运算符：
2.面向对象编程
C.类和对象
总结
D.继承
继承的限制
E.多态：方法重载和重写
多态的优势
多态的条件
F.抽象类和接口
适用场景
3.其他重要方法
字符串拼接
G.常用工具类
java.util 包下的工具类
Arrays 类
Random 类
java.lang 包下的工具类
Math 类
A.数据结构：数据类型分为引用数据类型和基本数据类型
基本数据类型分为4类：
- 整数类型：
byte、short、int、long。 - 浮点类型：
float、double。 - 字符类型：
char。 - 布尔类型：
boolean。
整数类型：
byte- 字节数：1 个字节（8 位）。
- 容量（取值范围）：即 -128 到 127。
short- 字节数：2 个字节（16 位）。
- 容量（取值范围）：即 -32768 到 32767。
int- 字节数：4 个字节（32 位）。
- 容量（取值范围）：即 -2147483648 到 2147483647。
long- 字节数：8 个字节（64 位）。
- 容量（取值范围）：即 -9223372036854775808 到 9223372036854775807。
浮点类型
float- 字节数：4 个字节（32 位）。
- 容量（取值范围）：大约 ±3.40282347×1038（有效位数大约为 6 - 7 位）。
double- 字节数：8 个字节（64 位）。
- 容量（取值范围）：大约 ±1.79769313486231570×10308（有效位数大约为 15 位）。
字符类型
char- 字节数：2 个字节（16 位）。
- 容量（取值范围）：
\u0000到\uffff，即 0 到 65535。它可以用来表示 Unicode 字符
引用数据类型：包括类，接口，数组等
import java.util.Date;
public class ReferenceDataTypes {
public static void main(String[] args) {
// 类类型
Date date = new Date();
System.out.println("Date: " + date);
// 数组类型
int[] intArray = {1, 2, 3, 4, 5};
System.out.print("Array: ");
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + " ");
}
}
}其中的Date类的对象和数组都属于引用数据类型
-
变量：是存储数据的容器（先声明再使用）
总结：基本数据类型存储的是具体的值，而引用数据类型存储的是对象的引用。
B.运算符：
位运算符用于对整数类型的二进制位进行操作，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）和无符号右移（>>>）。
按位与（&）：全1才1，有0则0
public class BitwiseAndExample {
public static void main(String[] args) {
int a = 5; // 二进制: 0101
int b = 3; // 二进制: 0011
int result = a & b; // 二进制: 0001
System.out.println("5 & 3 = " + result);//输出十进制的1
}
}按位或（|）：全0才0，有1则1
public class BitwiseOrExample {
public static void main(String[] args) {
int a = 5; // 二进制: 0101
int b = 3; // 二进制: 0011
int result = a | b; // 二进制: 0111
System.out.println("5 | 3 = " + result);//输出十进制的7（0111）
}
}按位取反（~）：1变0，0变1
public class BitwiseNotExample {
public static void main(String[] args) {
int a = 5; // 二进制: 0101
int result = ~a; // 二进制: 1010
System.out.println("~5 = " + result);输出十进制的-6（1010，java采用补码表示）
}
}左移（<<)：相当于乘以2的n次方
public class LeftShiftExample {
public static void main(String[] args) {
int a = 5; // 二进制: 0101
int result = a << 2; // 二进制: 010100
System.out.println("5 << 2 = " + result);//5*2^2=20
}
}右移（>>):相当于除以2的n次方
public class RightShiftExample {
public static void main(String[] args) {
int a = 5; // 二进制: 0101
int result = a >> 1; // 二进制: 0010
System.out.println("5 >> 1 = " + result);//输出十进制的2（0010）
}
}2.面向对象编程
C.类和对象
类是对具有相同属性和行为的一组对象的抽象描述，它定义了对象的属性（成员变量）和行为（成员方法）。可以把类看作是创建对象的模板。
类的定义使用class关键字
[访问修饰符] class 类名 {
// 成员变量（属性）
[访问修饰符] 数据类型 变量名;
// 成员方法（行为）
[访问修饰符] 返回值类型 方法名(参数列表) {
// 方法体
}
}访问修饰符：
public（公共的）修饰的，在任何地方都能被访问
private（私有）修饰的，只能在类中访问
protected（受保护的）修饰的，包内访问，也可以在不同包的子类访问。
public > protected > private
例如定义一个student类
public class Student {
private String name;
private int age;
// 无参构造方法
public Student() {
name = "未知";
age = 0;
}
// 带参构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void study() {
System.out.println(name + "正在学习。");
}
}
在这个示例中,Student类包含了一个无参构造方法和一个带参构造方法。无参构造方法将 name 初始化为 "未知",age初始化为 0；带参构造方法接受name和age作为参数，并将其赋值给对象的成员变量。
public class Main {
public static void main(String[] args) {
// 使用无参构造方法创建对象
Student student1 = new Student();
System.out.println("姓名：" + student1.getName() + "，年龄：" + student1.getAge());
// 使用带参构造方法创建对象
Student student2 = new Student("李四", 22);
System.out.println("姓名：" + student2.getName() + "，年龄：" + student2.getAge());
}
}第一个会打印，姓名：未知，年龄：0
第二个会打印，姓名：李四，年龄：22
总结
- 类：是对象的抽象描述，定义了对象的属性和行为。
- 对象：是类的具体实例，通过new关键字创建。
- 构造方法：用于在创建对象时对对象进行初始化，分为无参构造方法和带参构造方法。
D.继承
它允许一个类（子类）继承另一个类（父类）的属性和方法。
class 父类 {
// 父类的成员变量和成员方法
}
class 子类 extends 父类 {
// 子类可以拥有自己额外的成员变量和成员方法
}例子：
class Animal {
public void makeSound() {
System.out.println("动物发出声音。");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("猫咪喵喵叫。");
}
}
public class MethodOverrideExample {
public static void main(String[] args) {
Cat cat = new Cat();
cat.makeSound();
}
}其中Cat类继承了父类Animal，并重写了方法makeSoud使得cat拥有喵喵叫的能力（@Override）
重写：
当子类继承父类后，如果子类需要对父类的某个方法进行修改或扩展，可以在子类中重新定义这个方法，这就是方法重写。
条件：
- 方法名、参数列表和返回值类型必须与父类中被重写的方法一致。
- 访问修饰符不能比父类中被重写的方法更严格。
super：
关键字用于在子类中引用父类的成员，包括成员变量、成员方法和构造方法。
class Parent {
int value = 10;
public void display() {
System.out.println("父类的 display 方法。");
}
}
class Child extends Parent {
int value = 20;
public void show() {
System.out.println("子类的 value: " + value);
System.out.println("父类的 value: " + super.value);
super.display();
}
}
public class SuperKeywordExample {
public static void main(String[] args) {
Child child = new Child();
child.show();
}
}在这个示例中,Child类中使用super.value()访问父类的value成员变量，使用super.display()调用父类的display方法。
继承的限制
- Java 只支持单继承，即一个子类只能继承一个父类。但可以通过接口实现多继承的效果。
- 父类的私有成员（使用private修饰的成员变量和方法）不能被子类继承。
E.多态：方法重载和重写
重载（避开为每个方法都取名）：
class Calculator {
// 两个整数相加
public int add(int a, int b) {
return a + b;
}
// 三个整数相加
public int add(int a, int b, int c) {
return a + b + c;
}
// 两个双精度浮点数相加
public double add(double a, double b) {
return a + b;
}
}
public class CompileTimePolymorphism {
public static void main(String[] args) {
Calculator calculator = new Calculator();
// 调用两个整数相加的方法
System.out.println(calculator.add(1, 2));
// 调用三个整数相加的方法
System.out.println(calculator.add(1, 2, 3));
// 调用两个双精度浮点数相加的方法
System.out.println(calculator.add(1.5, 2.5));
}
}多态的优势
- 可扩展性：能够在不修改现有代码的基础上，通过添加新的子类来扩展系统功能。
- 可维护性：可以提高代码的可维护性，因为只需要在父类中定义通用的方法，具体实现由子类完成。
- 灵活性：允许使用父类引用指向不同的子类对象，从而实现不同的行为。
多态的条件
- 继承：子类必须继承父类，或者实现接口。
- 方法重写：子类需要重写父类的方法。
- 父类引用指向子类对象：使用父类的引用变量来引用子类的对象。
F.抽象类和接口
抽象类：抽象类是用abstract关键字修饰的类，它可以包含抽象方法和非抽象方法。抽象类不能被实例化，必须由子类继承并实现其抽象方法。（提供需要的类或方法，由子类具体完成）
abstract class 抽象类名 {
// 抽象方法
abstract 返回值类型 抽象方法名(参数列表);
// 非抽象方法
返回值类型 非抽象方法名(参数列表) {
// 方法体
}
}例子：
// 定义抽象类 Animal
abstract class Animal {
// 抽象方法
public abstract void makeSound();
// 非抽象方法
public void sleep() {
System.out.println("动物正在睡觉。");
}
}
// 定义子类 Dog，继承自 Animal
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("狗狗汪汪叫。");
}
}
// 定义子类 Cat，继承自 Animal
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("猫咪喵喵叫。");
}
}
public class AbstractClassExample {
public static void main(String[] args) {
// 不能实例化抽象类
// Animal animal = new Animal();
Dog dog = new Dog();
dog.makeSound();
dog.sleep();
Cat cat = new Cat();
cat.makeSound();
cat.sleep();
}
}Anim是抽象类，包含抽象方法makeShoud和非抽象方法sleep。Dog和Cat类继承自Animal类，并实现了makeSoud方法。（子类继承抽象类后必须重写抽象类的所有方法）。
接口：
使用interface关键字定义。接口中的方法默认是 public abstract 类型，即抽象方法，并且接口中的变量默认是 public static final 类型，即常量。类可以实现一个或多个接口，通过 implements 关键字来实现。
interface 接口名 {
// 常量定义
数据类型 常量名 = 值;
// 抽象方法
返回值类型 抽象方法名(参数列表);
}例子
// 定义接口 AnimalBehavior
interface AnimalBehavior {
// 常量
int LEGS = 4;
// 抽象方法
void makeSound();
void move();
}
// 定义类 Dog，实现 AnimalBehavior 接口
class Dog implements AnimalBehavior {
@Override
public void makeSound() {
System.out.println("狗狗汪汪叫。");
}
@Override
public void move() {
System.out.println("狗狗在奔跑。");
}
}
// 定义类 Cat，实现 AnimalBehavior 接口
class Cat implements AnimalBehavior {
@Override
public void makeSound() {
System.out.println("猫咪喵喵叫。");
}
@Override
public void move() {
System.out.println("猫咪在走路。");
}
}
public class InterfaceExample {
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound();
dog.move();
System.out.println("狗狗有 " + AnimalBehavior.LEGS + " 条腿。");
Cat cat = new Cat();
cat.makeSound();
cat.move();
System.out.println("猫咪有 " + AnimalBehavior.LEGS + " 条腿。");
}
}在这个示例中，AnimalBehavior 是接口，包含常量 LEGS 和抽象方法 makeSound 与 move。Dog 和 Cat 类实现了 AnimalBehavior 接口，并实现了接口中的抽象方法。
适用场景
- 抽象类：适用于具有相似特征和行为的一组类，可将通用的方法和属性放在抽象类中。
- 接口：适用于为不同的类定义统一的行为规范，实现多继承的效果。
3.其他重要方法
String类
字符串的比较
equals，比较两个字符串内容是否相等（==是判断地址是否相等）
String s1 = "abc";
String s2 = "abc";
boolean isEqual = s1.equals(s2);
System.out.println("两个字符串内容是否相等: " + isEqual);equalsIgnoreCase方法：用于忽略大小写比较两个字符串的内容是否相等
String s3 = "ABC";
String s4 = "abc";
boolean isEqualIgnoreCase = s3.equalsIgnoreCase(s4);
System.out.println("忽略大小写后两个字符串内容是否相等: " + isEqualIgnoreCase);字符串查找
indexOf 方法：用于查找指定字符或子字符串在字符串中第一次出现的索引位置。
String str = "Hello World";
int index = str.indexOf("World");
System.out.println("子字符串 'World' 第一次出现的索引位置: " + index);lastIndexOf 方法：用于查找指定字符或子字符串在字符串中最后一次出现的索引位置。
String str = "Hello World, World";
int lastIndex = str.lastIndexOf("World");
System.out.println("子字符串 'World' 最后一次出现的索引位置: " + lastIndex);字符串截取
substring 方法：用于截取字符串的一部分
String str = "Hello World";
// 从索引 6 开始截取到字符串末尾
String subStr1 = str.substring(6);
// 截取索引 0 到索引 5（不包含 5）的子字符串
String subStr2 = str.substring(0, 5);
System.out.println("截取的子字符串 1: " + subStr1);
System.out.println("截取的子字符串 2: " + subStr2);字符串替换
replace 方法：用于将字符串中的指定字符或子字符串替换为新的字符或子字符串。
String str = "Hello World";
String newStr = str.replace("World", "Java");
System.out.println("替换后的字符串: " + newStr);字符串分割
split 方法：用于根据指定的分隔符将字符串分割成字符串数组。
String str = "apple,banana,orange";
String[] fruits = str.split(",");
for (String fruit : fruits) {
System.out.println(fruit);
}字符串大小写转换
toUpperCase 方法：将字符串转换为大写。
String str = "hello";
String upperCaseStr = str.toUpperCase();
System.out.println("转换为大写后的字符串: " + upperCaseStr); toLowerCase 方法：将字符串转换为小写。
String str = "HELLO";
String lowerCaseStr = str.toLowerCase();
System.out.println("转换为小写后的字符串: " + lowerCaseStr);字符串拼接
除了使用 + 运算符进行字符串拼接外，还可以使用 StringBuilder 或 StringBuffer 类。
StringBuilder 是非线程安全的，在单线程环境下性能较好。
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString();
System.out.println("拼接后的字符串: " + result); StringBuffer 是线程安全的，在多线程环境下使用更合适。
StringBuffer sbf = new StringBuffer();
sbf.append("Hello");
sbf.append(" ");
sbf.append("World");
String result = sbf.toString();
System.out.println("拼接后的字符串: " + result);G.常用工具类
java.util 包下的工具类
Arrays 类
Arrays 类提供了一系列用于操作数组的静态方法，像排序、查找、比较等
import java.util.Arrays;
public class ArraysExample {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5, 9};
// 数组排序
Arrays.sort(arr);
System.out.println("排序后的数组: " + Arrays.toString(arr));
// 二分查找
int index = Arrays.binarySearch(arr, 4);
System.out.println("元素 4 的索引位置: " + index);
// 数组比较
int[] arr2 = {3, 1, 4, 1, 5, 9};
boolean isEqual = Arrays.equals(arr, arr2);
System.out.println("两个数组是否相等: " + isEqual);
}
}Random 类
Random 类用于生成随机数。
import java.util.Random;
public class RandomExample {
public static void main(String[] args) {
Random random = new Random();
// 生成 0 到 9 之间的随机整数
int randomNumber = random.nextInt(10);
System.out.println("随机数: " + randomNumber);
}
}java.lang 包下的工具类
Math 类
Math 类提供了许多数学运算的静态方法，如三角函数、对数函数、绝对值等。
public class MathExample {
public static void main(String[] args) {
// 求绝对值
double absValue = Math.abs(-3.14);
System.out.println("-3.14 的绝对值: " + absValue);
// 求最大值
int max = Math.max(10, 20);
System.out.println("10 和 20 中的最大值: " + max);
// 生成随机数
double random = Math.random();
System.out.println("0 到 1 之间的随机数: " + random);
}
}