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
修饰的成员变量或方法,在类外不能被访问
表對應
public | private | protected | default |
---|---|---|---|
類內部✅ | 類內部✅ | 類內部✅ | 類內部✅ |
本包✅ | 本包❌ | 本包✅ | 本包✅ |
子包✅ | 子包❌ | 子包✅ | 子包❌ |
外部包✅ | 外部包❌ | 外部包❌ | 外部包❌ |
2.java變量&常量
变量
變量定義:
基本數據類型
在Java中 小數默認為double
, 整數默認為int
整形 | 浮點型 | 字符 | 布爾值 |
---|---|---|---|
byte 字節 8bit 1字節 -128~127 | float 浮點型 32bit 4字節 | char 字符型 16bit 2字節 | boolean 布爾值 1bit |
short 短整型 16bit 2字節 -32768~32767 | double 浮點型 64bit 8字節 | / | / |
int 整型 32bit 4字節 -2147483648~2147483647 | / | / | / |
long 長整型 64bit 8字節 -9223372036854775808~9223372036854775807 | / | / | / |
引用數據類型
String
/ 數組類型
/ 接口
/ 類
棧:
- 對象引用
- 基本數據類型
方法區(java1.8 before):
class
文件static
變量與方法
堆:
- 一切
new
出來的對象
變量的類型轉換
- 自動類型轉換
- 數據類型小的轉換到數據類型大的,稱為自動類型轉換
- 比如:
byte
->short
->int
->long
->float
->double
- 強制類型轉換
- 比如:
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. 父類指向子類对象
多态的好处
- 避免了重复代码
- 避免了类与类之间的耦合性
Java中多态实现方式是
- 接口实现
- 继承父类进行方法重写
- 同一个类中进行方法重载
- 父类引用指向子类对象
掌握類的實例化
// 定义一个简单的类
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
方法對隱藏的信息進行訪問
封裝的實現步驟
- 將類的屬性設置為私有的(
private
)- 在類中提供對這些屬性的訪問方法(
getter
/setter
) (通過這兩種方法對數據進行獲取和設定, 對象通過調用這兩種方法實現對數據的讀寫)- 在
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;
}
- 被
static
修飾的變量, 可以通過類名, 變量名直接引用, 而不需要new出一個類來 - 被
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
关键字来定义接口
- 接口中所有定義的方法中其實都是抽象的
public abstract
- 變量只能為
public static final
類型的 public abstract void method();
等效於void method();
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");
}
}
注意接口和抽象類區別
- 接口都是要被子類實現的, 而抽象類要被子類繼承
- 接口中變量全為公共靜態常量, 而抽象類中可以有普通變量
- 接口中全為方法的聲明, 而抽象類中可以有方法的實現
- 接口中不可以有構造函數, 而抽象類可以有構造函數
- 接口有多實現, 而抽象類只有一個實現
- 接口中全為抽象方法, 而抽象類可以有抽象方法跟普通方法