当前位置: 首页 > article >正文

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

Java基礎2小時速成 - 上篇

  • java權限修飾符
    • 表對應
  • 2.java變量&常量
    • 基本數據類型
    • 引用數據類型
    • 變量的類型轉換
    • java中的常量
  • 3.java 選擇與循環
  • 4.java數組
    • 數組
    • 多維數組初始化三種方式
    • 數組的常見操作
      • 1. 聲明數組
      • 2. 數組的初始化
      • 3. 數組的循環 foreach
      • 4. 數組的拷貝
      • 5. 數組的排序
      • 6. 將int數組轉換為String
  • java輸入輸出
    • 輸入
    • 輸出
  • java類與對象
    • 掌握java中的面向對象三大特徵
    • 掌握類的實例化
    • 掌握類的定義格式
  • java继承性
    • Object类
    • 继承 重寫
  • java類的封裝
  • java構造方法
    • 无参构造器
    • 有参构造器
  • java重載&重寫
    • 重載概念
    • 方法重寫的注意事項
    • 重寫和重載的區別
  • java-static&final關鍵字
    • static
    • final
  • java抽象類
  • java接口
    • 注意接口和抽象類區別

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

请添加图片描述

java權限修飾符

java 權限修飾符有四種

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

表對應

publicprivateprotecteddefault
類內部✅類內部✅類內部✅類內部✅
本包✅本包❌本包✅本包✅
子包✅子包❌子包✅子包❌
外部包✅外部包❌外部包❌外部包❌

2.java變量&常量

变量

變量定義:

基本數據類型

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

整形浮點型字符布爾值
byte字節 8bit 1字節 -128~127float 浮點型 32bit 4字節char 字符型 16bit 2字節boolean 布爾值 1bit
short短整型 16bit 2字節 -32768~32767double 浮點型 64bit 8字節//
int整型 32bit 4字節 -2147483648~2147483647///
long長整型 64bit 8字節 -9223372036854775808~9223372036854775807///

引用數據類型

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");
    }
}

注意接口和抽象類區別

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

请添加图片描述


http://www.kler.cn/a/587476.html

相关文章:

  • 第十五届蓝桥杯C/C++B组拔河问题详解
  • Vision Transformer (ViT):将Transformer带入计算机视觉的革命性尝试(代码实现)
  • 7年全栈开发经验 · 兼职技术合作
  • ShenNiusModularity项目源码学习(16:ShenNius.Admin.Mvc项目分析-1)
  • L1-7 统一命名规范(java)
  • 【ESP32】ESP-IDF开发 | 经典蓝牙开发 | 蓝牙串口协议(SPP) + 客户端和服务端例程
  • MyBatis框架操作数据库一>xml和动态Sql
  • 基于单片机的豆浆机控制系统设计(论文+源码)
  • 软件环境安装-通过Docker安装RocketMQ
  • 安卓实现魔改版 Base64 算法
  • 什么是机器学习?从零基础到自动驾驶案例全解析
  • 阿里FPGA XCKU3P开箱
  • 国内Mac,nimi安装homebrew完整过程
  • Rust从入门到实战
  • 【Go每日一练】实现简单的控制台计算器
  • 简单的bug+1
  • 现代密码学 | 具有保密和认证功能的安全方案
  • 软考网络安全专业
  • 基于大模型预测的难治性青光眼诊疗方案研究报告
  • Leetcode:34(二分查找)