Java基礎2小時速成(上篇) - 掌握核心技术「卷」

                                    本篇適用於
                          ----======================----
                              - 考前急用Java基礎人群 -
                             - Java基礎知識點速記人群 -
                            - 像我一樣很久沒看java人群 -
                          ----======================----
                          若無基礎看不懂請不要來責怪本篇教程

java權限修飾符

java 權限修飾符有四種

• 1.public：表示公共的，可以在任何地方被访问
  • public 修饰的成员变量或方法，在类外不能被访问，但可以通过get/set方法访问
• 2.private：表示私有的，只能在当前类中被访问
  • private 修饰的成员变量或方法，在类外不能被访问
• 3.protected：表示受保护的，只能在当前类和子类中被访问
  • protected 修饰的成员变量或方法，在类外不能被访问
• 4.default（不写）：表示默认的，只能在当前包中被访问
  • default 修饰的成员变量或方法，在类外不能被访问

表對應

2.java變量&常量

变量

變量定義:

基本數據類型

在Java中 小數默認為double, 整數默認為int

引用數據類型

String / 數組類型 / 接口 / 類

棧:

• 對象引用
• 基本數據類型

方法區（java1.8 before）:

• class文件
• static變量與方法

堆:

• 一切new出來的對象

變量的類型轉換

1. 自動類型轉換
   • 數據類型小的轉換到數據類型大的，稱為自動類型轉換
   • 比如: byte -> short -> int -> long -> float -> double
2. 強制類型轉換
   • 比如: double -> float -> long -> int -> short -> byte
   • 數據類型大的轉換到數據類型小的，稱為強制類型轉換
   • 強制類型轉換要加(type)

   public class A {
       public static void main(String[] args) {
           int c = 3;
           float b = a; // int -> float 小轉大
           c = (int)b; // float -> int 大轉小 需要强转
       }
   }
   

java中的常量

• 常量是定義在類中的，並且使用 final 關鍵字進行修飾
  • 類中定義的常量，只能使用 static 修飾符
  • 常量不可改變，所以常量在類中定義的時候，一定要給初值

3.java 選擇與循環

看看語法就好…

選擇語句 if / else if / else / switch / case / default / break

public static void main(String[] args) {
    if (a == 1) {

    } else if (a == 2) {

    } else {

    }

    // ----------------------------

    switch (a) {
        case 1:
            System.out.println("1");
            break; // 中斷
        default: // 可有可無
            System.out.println("default");
    }
}

循環語句 while / do while / for / for each

public static void main(String[] args) {
    int num = 1;
    int sum = 0;

    while (num <= 10) {
        sum = sum + num;
        num++;
    }
    System.out.println("1 到 10 的整数之和是: " + sum);

    // ----------------------------

    int num = 1;
    int sum = 0;

    do {
        sum = sum + num;
        num++;
    } while (num <= 5);

    System.out.println("1 到 5 的整数之和是: " + sum);

    // ----------------------------

    for (int i = 1; i <= 10; i++) {
        System.out.println(i);
    }

    // ----------------------------

    // 创建一个包含整数的列表
    List<Integer> numbers = new ArrayList<>();
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
    numbers.add(4);
    numbers.add(5);

    // 使用 foreach 循环遍历列表
    for (int number : numbers) {
        System.out.println(number);
    }

    // 遍历数组
    int[] numberArray = {10, 20, 30, 40, 50};
    for (int num : numberArray) {
        System.out.println(num);
    }
}

4.java數組

數組

• 不允許在前面的括號寫元素個數

多維數組初始化三種方式

public static void main(String[] args) {
    int a[][] = new int[3][];
    a[0] = new int[3]; // 0行 -> 有三列
    a[1] = new int[2]; // 1行 -> 有兩列
    a[2] = new int[1]; // 2行 -> 有一列
    System.out.println(Arrays.toString(a[1]));

    // --------------------------------------

    int a[][] = new int[3][2];
    a[0][1] = 1;
    System.out.println(Arrays.toString(a[0]));

    // --------------------------------------

    // 靜態初始化方式
    int a[][] = new int[][]{{12, 3, 4}, {1, 2, 3}};
    System.out.println(Arrays.toString(a[1]));
}

數組的常見操作

1. 聲明數組

int arr[];

2. 數組的初始化

int a[] = new int[]{1, 3, 4}; // 靜態初始化

int a1[] = new int[3]; // 動態初始化
a1[0] = 1;
a1[1] = 2;
a1[2] = 3;

System.out.println(a.length); // 打印數組長度

3. 數組的循環 foreach

for (int i : a) {
    System.out.println(i); // 1, 3， 4
}

4. 數組的拷貝

int b[] = a;
// copyOf(a, a.length) 第一個參數是copy目標，第二個參數是copy長度
int b1[] = Arrays.copyOf(a, a.length);

5. 數組的排序

int a[] = new int[]{111, 32, 456};
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [32, 111, 456]

6. 將int數組轉換為String

Arrays.toString(arr);

java輸入輸出

輸入

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.next();
        System.out.println(a);
        sc.close();
    }
}

輸出

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World");
        System.out.print("Hello World");

        int a = 1;
        System.out.printf("输出A为: %d", a);
    }
}

java類與對象

掌握java中的面向對象三大特徵

通过 private / public / protected / default 关键字实现属性或方法的封装, 进对外提供公共访问方式

// Student.java
public class Student {
    private String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setUsername("张三");
        System.out.println(student.getUsername());
    }
}

封装的好处?

1. 实现数据项和方法的隐藏
2. 实现隐藏隔离, 允许外部对类做有限的访问, 开发者可以自由的改变类的内部实现
3. 提高了代码的重用性

继承

通过继承, 可以实现代码复用, 避免重复书写
通过继承 实现对现实世界更加准确的建模

多态

一个对象变量可以指向多种实际类型对象的现象被稱為多态性
三个必要条件: 1. 繼承 2. 方法重写 3. 父類指向子類对象

多态的好处

1. 避免了重复代码
2. 避免了类与类之间的耦合性

Java中多态实现方式是

1. 接口实现
2. 继承父类进行方法重写
3. 同一个类中进行方法重载
4. 父类引用指向子类对象

掌握類的實例化

// 定义一个简单的类
class Person {
    // 无参构造方法
    Person() {}
}

public class Main {
    public static void main(String[] args) {
        // 实例化 Person 类，创建一个对象
        Person person = new Person();
    }
}

掌握類的定義格式

[修饰符] class 类名 [extends 父类名] [implements 接口名] {
    // 类体 包括类的成员变量和成员方法
}

java继承性

Object类

Object类是所有类的父类, 所有类都继承自Object类

1. getClass() 返回当前对象的类
2. hashCode() 返回当前对象的哈希码
3. equals(Object obj) 判断两个对象是否相等
4. clone() 返回当前对象的一个副本
5. toString() 返回当前对象的字符串表示
// ......

继承 重寫

// Parent.java

package com.test;

public class Parent {
    private int age;

    public Parent() {
    }

    public Parent(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void myFc() {
        System.out.println("自定義");
    }
}

class Son extends Parent{

    // 重寫
    public void myFc() {
        System.out.println("子類重寫");
    }

    public static void main(String[] args) {
        Son son = new Son();
        son.myFc();
        son.setAge(22);
        int receivedAge = son.getAge();
        System.out.println("receivedAge = " + receivedAge);
    }
}

java類的封裝

將類的某些信息隱藏在類的內部, 不允許對外訪問, 而是通過 getter/setter 方法對隱藏的信息進行訪問

封裝的實現步驟

1. 將類的屬性設置為私有的(private)
2. 在類中提供對這些屬性的訪問方法(getter/setter) (通過這兩種方法對數據進行獲取和設定, 對象通過調用這兩種方法實現對數據的讀寫)
3. 在getter/setter方法中加入屬性控制語句 (對屬性值的合法性進行判斷)

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            System.out.println("age小於0");
        } else {
            this.age = age;
        }
    }
}

class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(-1);
        person.setName("tom");
        System.out.println(person.getAge());
        System.out.println(person.getName());
    }
}

java構造方法

有參數構造器&無參數構造器

无参构造器

• 定义:
  • 无参构造器是没有参数的构造方法
  • 如果一个类中没有显式定义任何构造器，Java 编译器会自动为该类提供一个默认的无参构造器
  • 当你显式定义了构造器后，默认的无参构造器将不再提供
• 用途:
  • 对象的基本初始化：在创建对象时，如果不需要传入特定的初始值，无参构造器可以对对象进行一些默认的初始化操作
  • 例如，将对象的属性设置为默认值
• 简化对象创建:
  • 当创建对象时不需要额外的初始化信息时，使用无参构造器可以使代码更加简洁

// 無參構造器
class Person {
    private String name;
    private int age;

    // 无参构造器
    public Person() {
        name = "未知";
        age = 0;
        System.out.println("使用无参构造器创建对象");
    }

    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.displayInfo();
    }
}

有参构造器

• 定义:
  • 有参构造器是带有参数的构造方法，它允许在创建对象时传入特定的值，用于初始化对象的属性
• 用途:
  • 对象的个性化初始化：当创建对象时需要为对象的属性赋予特定的初始值，有参构造器可以满足这一需求
  • 通过传入不同的参数，可以创建具有不同初始状态的对象
• 确保对象的有效状态:
  • 有参构造器可以在对象创建时对传入的参数进行验证，确保对象在创建后处于有效状态

class Rectangle {
    private double length;
    private double width;

    // 有参构造器
    public Rectangle(double length, double width) {
        if (length > 0 && width > 0) {
            this.length = length;
            this.width = width;
            System.out.println("使用有参构造器创建矩形对象");
        } else {
            System.out.println("输入的长度和宽度必须大于 0");
        }
    }

    public double getArea() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(5.0, 3.0);
        System.out.println("矩形的面积: " + rectangle.getArea());
    }
}

java重載&重寫

重載概念

• 必須在同一個類中
• 方法名相同
• 方法的參數個數 \ 順序 \ 類型不同
• 與方法的修飾符合返回值沒有關係

// 方法重载的基本使用，通过定义同名但参数列表不同的方法，实现了不同类型和数量参数的加法运算
public class MethodOverloadingExample {
    // 计算两个整数的和
    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 static void main(String[] args) {
        MethodOverloadingExample example = new MethodOverloadingExample();

        // 调用两个整数相加的方法
        int result1 = example.add(2, 3);
        System.out.println("两个整数的和: " + result1);

        // 调用三个整数相加的方法
        int result2 = example.add(2, 3, 4);
        System.out.println("三个整数的和: " + result2);

        // 调用两个双精度浮点数相加的方法
        double result3 = example.add(2.5, 3.5);
        System.out.println("两个双精度浮点数的和: " + result3);
    }
}

方法重寫的注意事項

• 重寫方法必須和父類一模一樣，包括方法名、參數列表、返回值類型，但可以增加修飾符
• 重寫的方法可以使用 @Override 註解來標識
• 子類重寫的方法的訪問權限不能低於父類種方法的訪問權限 權限修飾符(private < 默認什麼都不寫(default) < protected < public)

// 父类
class Animal {
    // 父类方法，使用 protected 修饰符
    protected String makeSound() {
        return "动物发出声音";
    }
}

// 子类，继承自 Animal 类
class Dog extends Animal {
    // 使用 @Override 注解标识这是一个重写方法
    @Override
    // 重写方法，将访问权限提升为 public
    public String makeSound() {
        return "汪汪汪";
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.makeSound());
    }
}

重寫和重載的區別

• 重載: 在同一個類中，方法名相同，參數列表不同，返回值類型&修飾符可以相同也可以不同
• 重寫: 子類中出現和父類中一模一樣的方法（包夸返回值類型, 方法名, 參數列表）

java-static&final關鍵字

static

靜態變量 & 靜態方法

private static String str1 = "str1";

public static void print2() {
    System.out.println(str1);
    System.out.println(str2);
    print1();
}

靜態代碼塊

static {
    static int a = 3;
}

1. 被 static 修飾的變量, 可以通過類名, 變量名直接引用, 而不需要new出一個類來
2. 被 static 修飾的方法, 可以通過類名, 方法名直接引用, 而不需要new出一個類來

public class Parent {
    static {
        int a = 3;
    }

    private static String name = "name";

    public static void myPrint() {
        System.out.println("myPrint靜態方法");
    }
}

class Son extends Parent {

}

class Test {
    public static void main(String[] args) {
        // 不加static
        // Parent p = new Parent();
        // p.myPrint();

        // 加static
        Parent.myPrint();
    }
}

final

final 修飾的類不能被繼承
final 修飾的方法, 不能被重寫, 但是子類可以用父類中 final 修飾的方法
final 修飾的變量, 值不能被修改

對於引用類型被final修飾了: 引用變量引用不可變, 但是引用對象的內容可以被改變

public class Test {
    public static void main(String[] args) {
        A a = new A();
        // A a = new B(); ❌
        a.a = 3;
        a.a = 4;
    }
}

final class A {
    public int a = 3;
}

java抽象類

抽象類的定義 在類的前面添加abstract
內部可以有普通變量, 公共靜態變量, 普通方法, 抽象方法

public abstract class AbstractTest {
    public String username;
    int a = 3;
    public static int age = 33;

    public void myMethod() {
        System.out.println(a);
    }

    public abstract void myStaticMethod();
}

class Child extends AbstractTest {

    @Override
    public void myStaticMethod() {
        System.out.println("Child");
    }
}

java接口

使用 interface 关键字来定义接口

1. 接口中所有定義的方法中其實都是抽象的 public abstract
2. 變量只能為 public static final 類型的
3. public abstract void method(); 等效於 void method();
4. int age = 10; 等效於 public static final int age = 10;

public interface MyInterface {
    int age = 3; // public static final int age = 3;
    void myMethod(); // public abstract void myMethod();
    void insertA(Parent p); // public abstract int insertA(Parent p);
}

如果需要實現接口使用 implements 關鍵字

public class UserTest implements MyInterface {
    public void myMethod() {
        System.out.println("myMethod");
    }
    public void insertA(Parent p) {
        System.out.println("insertA");
    }
}

注意接口和抽象類區別

• 接口都是要被子類實現的, 而抽象類要被子類繼承
• 接口中變量全為公共靜態常量, 而抽象類中可以有普通變量
• 接口中全為方法的聲明, 而抽象類中可以有方法的實現
• 接口中不可以有構造函數, 而抽象類可以有構造函數
• 接口有多實現, 而抽象類只有一個實現
• 接口中全為抽象方法, 而抽象類可以有抽象方法跟普通方法