Hello World

配置環(huán)境

假如 JDK 解壓縮后的包在 /home/cunyu/soft/jdk-11.0.7 目錄，則在 /etc/profile 文件中加入如下配置：

JAVA_HOME = /home/cunyu/soft/jdk-11.0.7

PATH = $JAVA_HOME/bin:$PATH

命令行運(yùn)行程序

# 編譯

javac HelloWorld.java

# 運(yùn)行

java HelloWorld

面向?qū)ο?/p>

類和對(duì)象

public class Item{

// 物品名

String name;

// 價(jià)格

int price;

public static void main(String[] args){

Item hp = new Item();

hp.name = "血瓶";

hp.price = 50;

Item shoes = new Item();

shoes.name = "草鞋";

shoes.price = 300;

Item sword = new Item();

sword.name = "長(zhǎng)劍";

sword.price = 530;

}

}

方法

public class Item{

// 物品名

String name;

// 價(jià)格

int price;

// 血量

float hp;

public legendary(){

System.out.println("超神");

}

public float getHp(){

return hp;

}

public void recovery(float blood){

hp += blood;

}

}

變量

基本數(shù)據(jù)類型

總共有 8 大基本數(shù)據(jù)類型整性byte，1 個(gè)字節(jié)，8 位

short，2 個(gè)字節(jié)， 16 位

int，4 個(gè)字節(jié)，32 位

long，8 個(gè)字節(jié)，64 位

浮點(diǎn)型float，4 個(gè)字節(jié)，32 位

double，8 個(gè)字節(jié)，64 位字符型char，2 個(gè)字節(jié)，16 位

布爾型boolean，1 位

字面值

給基本數(shù)據(jù)類型變量賦值的方式叫做 字面值；

類型轉(zhuǎn)換

轉(zhuǎn)換規(guī)則

從小達(dá)到自動(dòng)轉(zhuǎn)，從大到小強(qiáng)制轉(zhuǎn)；高精度向低精度轉(zhuǎn)換，可能導(dǎo)致溢出；

低精度可以向高精度轉(zhuǎn)換；

不同數(shù)據(jù)類型之間相互轉(zhuǎn)換需要進(jìn)行 強(qiáng)制轉(zhuǎn)換；

命名規(guī)則及建議變量命名只能使用 字母、數(shù)字、_、$；

變量第一個(gè)字符只能 字母、$、_，不能是 數(shù)字；

變量命名不能使用關(guān)鍵字，但可以包含關(guān)鍵字；

盡量使用完整單詞，而非縮寫(xiě)；

塊

Java 中 {} 包括的部分，稱為一個(gè)塊；

作用域字段、屬性、Field

當(dāng)變量聲明在 類下 時(shí)，叫做 字段，或者 屬性、成員變量、Field，作用域 從聲明的位置開(kāi)始的整個(gè)類；參數(shù)

當(dāng)變量聲明在 方法上 時(shí)，叫做 參數(shù)，作用域?yàn)?該方法內(nèi)所有代碼，其他方法和類都不能訪問(wèn)；局部變量

當(dāng)變量聲明在 方法內(nèi) 時(shí)，叫做 局部變量，作用域?yàn)?從聲明的位置開(kāi)始，直到所處于的塊結(jié)束；

final 修飾符

當(dāng)聲明一個(gè)用 final 修飾的變量時(shí)，說(shuō)明該變量 有且只有一次賦值的機(jī)會(huì)；

操作符

算數(shù)操作符+、-、×、/、%、++、--

當(dāng)不同的運(yùn)算單元(任一長(zhǎng)度超過(guò) int)進(jìn)行運(yùn)算時(shí)，最終返回結(jié)果按照最長(zhǎng)的長(zhǎng)度計(jì)算；

當(dāng)不同的運(yùn)算單元(任一長(zhǎng)度不超過(guò) int)進(jìn)行運(yùn)算時(shí)，最終返回結(jié)果按照 int 計(jì)算；

++、-- 前置時(shí)，先運(yùn)算，再取值；后置時(shí)、先取值，再計(jì)算；

關(guān)系操作符>、>=、

邏輯操作符&、&&、|、||、！、^

長(zhǎng)路與短路的區(qū)別：長(zhǎng)路會(huì)運(yùn)算符兩邊的值均進(jìn)行運(yùn)算，短路當(dāng)運(yùn)算符左側(cè)為 false 時(shí)，運(yùn)算符右側(cè)則不再計(jì)算；

位運(yùn)算符Integer.toBinaryString()、|、&、^、～、<>、>>>

>> 與 >>> 的區(qū)別>> 會(huì)將正數(shù)所有位右移，并在最前面補(bǔ) 0，會(huì)將負(fù)數(shù)所有位右移，并在最前面補(bǔ) 1；

>>> 會(huì)將負(fù)數(shù)的二進(jìn)制的第一位的 1 也向右移動(dòng)，然后在前面補(bǔ) 0，從而導(dǎo)致負(fù)數(shù)在無(wú)符號(hào)右移后，得到一個(gè)正數(shù)；

>> 移動(dòng)后數(shù)的正負(fù)性不變，>>> 移動(dòng)后變?yōu)檎龜?shù)；

三元操作符表達(dá)式?值1:值2，當(dāng)表達(dá)式為真時(shí)，返回值 1；當(dāng)表達(dá)式為假時(shí)，返回值 2；

控制流程

switchswitch 中可以使用 byte、short、int、char、String、enum；

每個(gè)表達(dá)式結(jié)束都應(yīng)該有一個(gè) break；

使用 String 的實(shí)質(zhì)還是使用正數(shù)，是通過(guò)編譯后將其轉(zhuǎn)化為 hash 值；

數(shù)組

創(chuàng)建數(shù)組數(shù)組是一個(gè) 長(zhǎng)度固定，包含 相同類型 數(shù)據(jù)的 容器；

若一個(gè)變量代表一個(gè)數(shù)組，則將這個(gè)變量叫做 引用；

// 聲明一個(gè)引用

int[] arr;

// 創(chuàng)建一個(gè)長(zhǎng)度為 10 的數(shù)組，且使用引用 arr 指向該數(shù)組

初始化數(shù)組分配空間與賦值同步

//分配長(zhǎng)度為 5 的數(shù)組，但未賦值

int[] a = new int[5];

//沒(méi)有賦值，那么就會(huì)使用默認(rèn)值,作為int類型的數(shù)組，默認(rèn)值是0

System.out.println(a[0]);

//進(jìn)行賦值

a[0] = 100;

a[1] = 101;

a[2] = 103;

a[3] = 120;

a[4] = 140;分配空間同時(shí)賦值

// 方式 1，分配空間同時(shí)賦值

int[] arr1 = new int[]{100,102,444,836,3236};

// 方式 2

int[] arr2 = {100,102,444,836,3236};

// 方式 3，分配空間的同時(shí)指定內(nèi)容

int[] arr3 = neew int[5]{100,102,444,836,3236};

數(shù)組排序

選擇排序思路

首先在未排序數(shù)組中找到最小元素，存放到排序數(shù)組的其實(shí)位置，然后再?gòu)氖Ｓ辔磁判虻脑刂袑ふ易钚〉脑?#xff0c;放到排序數(shù)組起始位置，以此類推直到數(shù)組所有元素排序完畢；實(shí)現(xiàn)

/**

* 選擇排序

* @param source 未排序數(shù)組

*/

public void selectSort(int[] source){

// 數(shù)組長(zhǎng)度

int size = source.lenth;

for(int i = 0; i < size; i++){

for(int j = i + 1; j < size; j++){

// 進(jìn)行交換，從小到大

if(source[i] > source[j]){

// 進(jìn)行交換，從大到小

// if(source[i] < source[j])

int tmp = source[i];

source[i] = source[j];

source[j] = tmp;

}

}

}

}

冒泡排序思路

通過(guò)雙層循環(huán)，內(nèi)層循環(huán)將相鄰的兩個(gè)數(shù)進(jìn)行比較，將最大的一個(gè)數(shù)以冒泡(兩兩交換)的形式傳送到數(shù)組尾部，每次將一個(gè)最大值傳到數(shù)組尾部，外層循環(huán)則實(shí)現(xiàn)依次將當(dāng)前最大值傳送，最終實(shí)現(xiàn)排序；實(shí)現(xiàn)

/**

* 冒泡排序

* @param source 未排序數(shù)組

*/

public void bubbleSort(int[] source){

// 數(shù)組長(zhǎng)度

int size = source.length;

for(int i = 0; i < size - 1; i++){

for(int j = 0; j < size - 1 - i; j++){

if(source[j] > source[j + 1]){

int tmp = source[j];

source[j] = source[j + 1];

source[j + 1] = tmp;

}

}

}

}

數(shù)組復(fù)制

數(shù)組一旦分配空間，就不再可變，當(dāng)我們需要在原有數(shù)組的基礎(chǔ)上增刪改查時(shí)，則需要對(duì)數(shù)組進(jìn)行復(fù)制；將一個(gè)數(shù)組的值復(fù)制到另一個(gè)數(shù)組

/**

* @param src 源數(shù)組

* @param srcPos 源數(shù)組要復(fù)制的起始位置

* @param dest 目的數(shù)組

* @param destPos 目的數(shù)組要放置的起始位置

* @param length 復(fù)制的長(zhǎng)度

*/

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)合并數(shù)組

import java.util.Arrays;

/**

* Created with IntelliJ IDEA.

* Version : 1.0

* Author : cunyu

* Email : cunyu1024@foxmail.com

* Website : https://cunyu1943.github.io

* 公眾號(hào) : 村雨遙

* Date : 2020/5/6 上午10:58

* Project : mavenDemo

* Package : PACKAGE_NAME

* Class : MergeArr

* Desc : 合并數(shù)組

*/

public class MergeArr {

public static void main(String[] args) throws Exception {

int[] arr1 = {1, 5, 7, 9};

int[] arr2 = {0, 4, 11, 45};

int destSize = arr1.length + arr2.length;

int[] mergeArr = new int[destSize];

merge(arr1, arr2, mergeArr);

System.out.println(Arrays.toString(mergeArr));

}

/**

* 合并數(shù)組

*

* @param arr1 源數(shù)組 1

* @param arr2 源數(shù)組 2

* @param destArr 合并后的數(shù)組

*/

public static void merge(int[] arr1, int[] arr2, int[] destArr) {

// 將數(shù)組 1 合并到最終數(shù)組

System.arraycopy(arr1, 0, destArr, 0, arr1.length);

// 將數(shù)組 2 合并到最終數(shù)組

System.arraycopy(arr2, 0, destArr, arr1.length, arr2.length);

}

}

Arrays

方法功能copyOfRange數(shù)組復(fù)制toString()轉(zhuǎn)換為字符串sort排序binarySearch搜索equals判斷是否相同fill填充

import java.util.Arrays;

/**

* Created with IntelliJ IDEA.

* Version : 1.0

* Author : cunyu

* Email : cunyu1024@foxmail.com

* Website : https://cunyu1943.github.io

* 公眾號(hào) : 村雨遙

* Date : 2020/5/6 下午1:27

* Project : mavenDemo

* Package : PACKAGE_NAME

* Class : ArraysOperation

* Desc : Arrays 常見(jiàn)操作

*/

public class ArraysOperation {

public static void main(String[] args) throws Exception {

int[] arr = {1, 9, 8, 49};

// 復(fù)制

int[] newArr = Arrays.copyOfRange(arr, 0, arr.length);

// 轉(zhuǎn)換為字符串

System.out.println(Arrays.toString(newArr));

// 排序

Arrays.sort(newArr);

// 搜索

System.out.println(Arrays.binarySearch(newArr, 8));

// 比較是否相等

System.out.println(Arrays.equals(arr, newArr));

// 填充

Arrays.fill(arr, 10);

System.out.println(Arrays.toString(arr));

}

}

類和對(duì)象

繼承

class Item{

String name;

int price;

}

public class Armor extends Item{

int ac;

public static void main(String[] args) {

Armor a1 = new Armor();

Armor a2 = new Armor();

// 布甲相關(guān)屬性

a1.name = "布甲";

a1.price = 300;

a1.hjdj =15;

// 鎖子甲相關(guān)屬性

a2.name = "鎖子甲";

a2.price = 500;

a2.hjdj =40;

}

方法重載

**方法重載 ** 指方法名一樣，但參數(shù)類型不一樣；

構(gòu)造方法

通過(guò)一個(gè)類構(gòu)建一個(gè)對(duì)象的過(guò)程叫做 實(shí)例化，而實(shí)例化是通過(guò) 構(gòu)造方法 來(lái)實(shí)現(xiàn)的；構(gòu)造方法名和類名一樣，但是 沒(méi)有返回類型，默認(rèn)會(huì)提夠一個(gè)無(wú)參的構(gòu)造方法，this 代表當(dāng)前對(duì)象；

public class Hero{

String name;

float hp;

float armor;

int moveSpeed;

Hero(String name, float hp, float armor, int moveSpeed){

this.name = name;

this.hp = hp;

this.armor = armor;

this.moveSpeed = moveSpeed;

}

}

訪問(wèn)修飾符常用修飾符

符號(hào)說(shuō)明private私有package/friendly/default默認(rèn)，protected受保護(hù)public公有修飾符作用域

自身同包子類不同包子類同包類其他類private訪問(wèn)不能繼承不能繼承無(wú)法訪問(wèn)無(wú)法訪問(wèn)package/friendly/default訪問(wèn)繼承不能繼承訪問(wèn)無(wú)法訪問(wèn)protected訪問(wèn)繼承繼承訪問(wèn)無(wú)法訪問(wèn)public訪問(wèn)繼承繼承訪問(wèn)訪問(wèn)修飾符使用場(chǎng)景屬性通常用 private 封裝；

方法一般用 public 方便調(diào)用；

會(huì)被繼承的方法，通常用 protected ；

package 使用較少；

原則：作用范圍盡量小；

類屬性定義：當(dāng)類中一個(gè)屬性被 static 修飾時(shí)，叫做 類屬性，也叫 靜態(tài)屬性，當(dāng)一個(gè)屬性被聲明為類屬性時(shí)，所有對(duì)象均共享一個(gè)值；

對(duì)象屬性 ：又叫 實(shí)例屬性，非靜態(tài)屬性；

對(duì)象屬性與類屬性的對(duì)比 ：不同對(duì)象的 對(duì)象屬性的值 都可能不一樣，但所有對(duì)象的 類屬性的值 都是一樣的；

若一個(gè)屬性對(duì)所有對(duì)象都不一樣，則該屬性應(yīng)該設(shè)計(jì)為 對(duì)象屬性，因?yàn)樗?跟著對(duì)象走；

若一個(gè)對(duì)象被所有對(duì)象共享，均一樣，則該屬性應(yīng)該被設(shè)計(jì)為 類屬性；

訪問(wèn)方式對(duì)象.類屬性 ：teemo.hp ；

類.類屬性 ：Hero.hp ，推薦使用；

類方法類方法 ：又叫做 靜態(tài)方法，被 static 修飾的方法，訪問(wèn)類方法，無(wú)需對(duì)象 存在就可以直接訪問(wèn)，若某一方法中 未調(diào)用任何對(duì)象屬性，則可以設(shè)計(jì)為類方法；

對(duì)象方法 ：又叫 實(shí)例方法，非靜態(tài)方法，訪問(wèn)一個(gè)對(duì)象方法，必須建立在 有一個(gè)對(duì)象 的前提上，若某一方法中 訪問(wèn)了對(duì)象屬性，則該方法 必須 設(shè)計(jì)為對(duì)象方法；

類方法調(diào)用方式：對(duì)象.類方法 ：teemo.die() ；

類.類方法 ：Hero.battleWin() ，推薦使用；

屬性初始化對(duì)象屬性初始化方式 ：聲明該屬性時(shí)初始化；

構(gòu)造方法中初始化；

初始化塊;

public class Hero{

// 聲明同時(shí)初始化

public String name = "teemo";

protected float hp;

float maxHP;

// 初始化塊初始化

{

maxHP = 999;

}

// 構(gòu)造方法中初始化

public Hero(){

hp = 100;

}

}類屬性初始化方式 ：聲明該屬性時(shí)初始化；

靜態(tài)初始化塊；

public class Hero{

public String name;

protected float hp;

float maxHP;

// 聲明時(shí)初始化

public static int itemCapacity = 10;

// 靜態(tài)初始化塊

static{

itemCapacity = 20;

}

}屬性初始化塊的執(zhí)行順序：

靜態(tài)初始化塊 -> 非靜態(tài)初始化塊 ->構(gòu)造方法 ；

單例模式定義 : 又叫 Singleton 模式，指在一個(gè)類在 JVM 中，只存在一個(gè)實(shí)例；

單例模式分類：餓漢式 ： 無(wú)論如何都會(huì)創(chuàng)建一個(gè)實(shí)例，通過(guò) public static 的 getInstance 方法獲取一個(gè)對(duì)象，每次獲取的都是同一個(gè)對(duì)象，屬于 立即加載，無(wú)論是否用到該對(duì)象，均加載；

懶漢式 ：只有在調(diào)用 getInstance 方法時(shí)才會(huì)創(chuàng)建實(shí)例，每次獲取的都是同一個(gè)對(duì)象，屬于 延遲加載，只有在使用該對(duì)象時(shí)才加載，同時(shí)具有 線程安全；

單例模式三要素 ：構(gòu)造方法私有化 ；

靜態(tài)屬性指向?qū)嵗?；

public staic 的 getInstance 方法，**返回上一個(gè)要素中的靜態(tài)屬性 ** ；

/**

* 餓漢式

*/

public class Earth{

// 私有構(gòu)造方法，使得無(wú)法在外部通過(guò) new 實(shí)例化

private Earth(){

}

// 定義類屬性同時(shí)初始化

private static Earth instance = new Earth();

// private static 方法，用于獲取對(duì)象

public static Earth getInstance(){

return instance;

}

public static void main(String[] args){

Earth earth1 = Earth.getInstance();

Earth earth2 = Earth.getInstance();

// true

System.out.println(earth1 == earth2)

}

}

/**

* 懶漢式

*/

public class Earth{

// 私有構(gòu)造方法，使得無(wú)法在外部通過(guò) new 實(shí)例化

private Earth(){

}

// 定義類屬性

private static Earth instance;

// private static 方法，用于獲取對(duì)象

public static Earth getInstance(){

// instance 未指向任何對(duì)象，將其實(shí)例化

if(instance == null){

instance = new Earth();

}

return instance;

}

public static void main(String[] args){

Earth earth1 = Earth.getInstance();

Earth earth2 = Earth.getInstance();

// true

System.out.println(earth1 == earth2)

}

}

枚舉類型枚舉是一種特殊的類，方便定義常量，一般都是全大寫(xiě)；

public enum Heros{

TANK,

WIZARD,

ASSASSIN,

WARRIOR,

ASSIST,

RANGED,

PUSH,

FARMING

}

public class Demo{

public static void main(String[] args){

for(Heros hero : Heros.values()){

System.out.println(hero);

}

}

}

接口與繼承

接口接口 無(wú)法用于實(shí)例化；

接口 無(wú)構(gòu)造方法；

接口中的 方法均為抽象方法；

無(wú)法包含成員變量，除了 static 和 final 變量；

接口支持多繼承；

對(duì)象轉(zhuǎn)型

向上轉(zhuǎn)型(子類轉(zhuǎn)父類、實(shí)現(xiàn)類轉(zhuǎn)接口)

Hero hero = new Hero();

AdHero ad = new AdHero();

hero = ad;

向下轉(zhuǎn)型(父類轉(zhuǎn)子類、接口轉(zhuǎn)實(shí)現(xiàn)類)

Hero hero = new Hero();

AdHero ad = new AdHero();

ad = (AdHero)hero;

重寫(xiě)

子類可以繼承父類對(duì)象方法，繼承后重復(fù)提供該方法，則叫做 方法的重寫(xiě)，也叫覆寫(xiě)(override)；

class Item{

String name;

int price;

public void buy(){

System.out.println("購(gòu)買");

}

public void effect(){

System.out.println("物品使用后生效");

}

}

public class LifePotion extends Item{

@override

public void effect(){

System.out.println("血瓶使用后回血");

}

}

多態(tài)操作符的多態(tài) ：同一操作符在不同情景下具有不同作用，如 + 兩側(cè)是整形，則代表 數(shù)字相加；若其中任意一個(gè)是字符串，則代表 字符串連接；

類的多態(tài)需要具備的條件 ：父類(接口)引用指向子類對(duì)象 ；

調(diào)用的方法經(jīng)歷重寫(xiě)；

public interface Mortal{

public void die();

}

public class Hero{

public String name;

protected float hp;

public Hero(String name, float hp){

this.name = name;

}

public void kill(Mortal m){

m.die();

}

public static void main(String[] args){

Hero hero = new Hero("趙云", 1000.0f);

APHero ap = new APHero("安琪拉", 400.0f);

ADHero ad = new ADHero("后羿", 450.0f);

ADAPHero adap = new ADAPHero("嫦娥", 600.0f);

hero.kill(ad);

hero.kill(ap);

hero.kill(adap);

}

}

public class ADHero extends Hero implements Mortal{

@override

public void die(){

System.out.println("AD 被擊殺");

}

}

public class APHero extends Hero implements Mortal{

@override

public void die(){

System.out.println("AP 被擊殺");

}

}

public class ADAPHero extends Hero implements Mortal{

@override

public void die(){

System.out.println("ADAP 被擊殺");

}

}

隱藏定義 ：父類和子類擁有相同名字的屬性或方法時(shí)，父類的同名屬性或方法形式上不見(jiàn)了，但實(shí)際仍存在；即對(duì)于被隱藏的屬性和方法，不會(huì)被覆蓋，當(dāng)父類引用指向子類對(duì)象時(shí)，調(diào)用的隱藏屬性或方法仍然是父類的，而不會(huì)發(fā)生動(dòng)態(tài)綁定；

public class Test {

public static void main(String[] args) {

Circle circle = new Circle();//本類引用指向本類對(duì)象

Shape shape = new Circle();//父類引用指向子類對(duì)象(會(huì)有隱藏和覆蓋)

System.out.println(circle.name);

circle.printType();

circle.printName();

//以上都是調(diào)用Circle類的方法和引用

System.out.println(shape.name);//調(diào)用父類被隱藏的name屬性

shape.printType();//調(diào)用子類printType的方法

shape.printName();//調(diào)用父類隱藏的printName方法

}

}

class Shape {

public String name = "shape";

public Shape(){

System.out.println("shape constructor");

}

public void printType() {

System.out.println("this is shape");

}

public static void printName() {

System.out.println("shape");

}

}

class Circle extends Shape {

public String name = "circle"; //父類屬性被隱藏

public Circle() {

System.out.println("circle constructor");

}

//對(duì)父類實(shí)例方法的覆蓋

public void printType() {

System.out.println("this is circle");

}

//對(duì)父類靜態(tài)方法的隱藏

public static void printName() {

System.out.println("circle");

}

}輸入結(jié)果如下 ：

shape constructor

circle constructor

circle

this is circle

circle

shape

this is circle

shape

Object 類

toString()

所有類均繼承自 Object ，所以所有類均有 toString() 方法，返回 當(dāng)前對(duì)象的字符串表達(dá) ；

finalize()

當(dāng)一個(gè)對(duì)象沒(méi)有任何引用指向的時(shí)候，就滿足垃圾回收的條件，當(dāng)被垃圾回收時(shí)，其 finalize() 方法就會(huì) 被虛擬機(jī) JVM 調(diào)用，此時(shí)無(wú)需開(kāi)發(fā)人員主動(dòng)調(diào)用；

equals()

用于判斷兩個(gè)對(duì)象內(nèi)容是否相同；

==

不屬于 Object 類的方法，用于判斷兩個(gè)對(duì)象是否相同(即判斷兩個(gè)引用是否指向同一對(duì)象)；

hashCode()

用于返回一個(gè)對(duì)象的哈希值；

getClass()

返回一個(gè)對(duì)象的 類對(duì)象，主要用于 反射機(jī)制；

final修飾類 ：final 修飾類時(shí)，表示當(dāng)前類不允許繼承；

修飾方法 ：final 修飾方法時(shí)，表示該方法不允許被重寫(xiě)；

修飾基本類型變量 ：final 修飾基本類型變量時(shí)，表示該變量只有一次賦值機(jī)會(huì)；

修飾引用 ：final 修飾引用時(shí)，表示該引用只有一次指向?qū)ο蟮臋C(jī)會(huì)；

抽象類定義：在類中聲明一個(gè)方法，該方法無(wú)具體實(shí)現(xiàn)，是一個(gè) “空” 方法，則該方法叫做抽象方法，用 abstract 修飾；而當(dāng)一個(gè)類有抽象方法時(shí)，該類必須被聲明為 抽象類，抽象類不能直接實(shí)例化；

接口與抽象類的區(qū)別 ：子類 可以實(shí)現(xiàn)多個(gè)接口，但只能繼承一個(gè)抽象類；

抽象類可以定義 public、package、protected、private、靜態(tài)和非靜態(tài)屬性、final 和非 final 屬性，但 接口中聲明的屬性只能是 public、靜態(tài)、final；

內(nèi)部類可以分為如下 4 類：非靜態(tài)內(nèi)部類 ：直接定義在一個(gè)類中，可以直接訪問(wèn)外部類的 private 屬性，內(nèi)部類實(shí)例化語(yǔ)法：內(nèi)部類 對(duì)象名 = new 外部類().new 內(nèi)部類();；

靜態(tài)內(nèi)部類 ：在一個(gè)類中聲明一個(gè)靜態(tài)內(nèi)部類，不能訪問(wèn)外部類的實(shí)例屬性和方法，只能訪問(wèn)外部類私有靜態(tài)成員，不需要一個(gè)外部類的實(shí)例為基礎(chǔ)，可以直接實(shí)例化，語(yǔ)法如下： 外部類.靜態(tài)內(nèi)部類 對(duì)象名 = new 外部類.靜態(tài)內(nèi)部類();

package charactor;

public class Hero {

public String name;

protected float hp;

private static void battleWin(){

System.out.println("battle win");

}

//敵方的水晶

static class EnemyCrystal{

int hp=5000;

//如果水晶的血量為0，則宣布勝利

public void checkIfVictory(){

if(hp==0){

Hero.battleWin();

//靜態(tài)內(nèi)部類不能直接訪問(wèn)外部類的對(duì)象屬性

System.out.println(name + " win this game");

}

}

}

public static void main(String[] args) {

//實(shí)例化靜態(tài)內(nèi)部類

Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();

crystal.checkIfVictory();

}

}匿名類 ：在 聲明一個(gè)類的同時(shí)實(shí)例化，使用外部局部變量時(shí)，該變量必修修飾為 final；

package charactor;

public abstract class Hero {

String name; //姓名

float hp; //血量

float armor; //護(hù)甲

int moveSpeed; //移動(dòng)速度

public abstract void attack();

public static void main(String[] args) {

ADHero adh=new ADHero();

//通過(guò)打印adh，可以看到adh這個(gè)對(duì)象屬于ADHero類

adh.attack();

System.out.println(adh);

Hero h = new Hero(){

//當(dāng)場(chǎng)實(shí)現(xiàn)attack方法

public void attack() {

System.out.println("新的進(jìn)攻手段");

}

};

h.attack();

//通過(guò)打印h，可以看到h這個(gè)對(duì)象屬于Hero$1這么一個(gè)系統(tǒng)自動(dòng)分配的類名

System.out.println(h);

}

}本地類 ：可以看作是 帶名字的匿名類，匿名類不同之處在于內(nèi)部類的是內(nèi)部類必須聲明在成員的位置，即與屬性和方法平等位置，而本地類和匿名類一樣，直接聲明在代碼塊，可以是任何地方；

package charactor;

public abstract class Hero {

String name; //姓名

float hp; //血量

float armor; //護(hù)甲

int moveSpeed; //移動(dòng)速度

public abstract void attack();

public static void main(String[] args) {

//與匿名類的區(qū)別在于，本地類有了自定義的類名

class SomeHero extends Hero{

public void attack() {

System.out.println( name+ " 新的進(jìn)攻手段");

}

}

SomeHero h =new SomeHero();

h.name ="地卜師";

h.attack();

}

}練習(xí)

public abstract class Item{

public abstract void disposable();

public static void main(String[] args) throws Exception{

Item item = new Item(){

public void disposable(){

System.out.println("一次性");

}

}

}

}

默認(rèn)方法

默認(rèn)方法自 JDK8 加入，指 接口中也可以加入具體方法(即默認(rèn)方法，聲明為 default)，而不僅限于抽象方法；

最后練習(xí)

public abstract class Animal{

protected int legs;

protected Animal(int legs){

this.legs = legs;

}

public abstract void eat();

public void walk(int legs){

if(legs > 0){

System.out.println("用" + legs + "條腿走路")

}

}

}

class Spider extends Animal{

protected Spider(int legs){

super(legs);

}

@Override

public void eat(){

System.out.println("蜘蛛吃東西");

}

}

public interface Pet{

String name;

public void setName(String name);

public String getName();

public void play();

}

class Cat extends Animal implements Pet{

String name;

protected Cat(String name){

super(4);

this.name = name;

}

public Cat(){

this.name = "";

}

@Override

public void eat(){

System.out.println("貓?jiān)诔贼~(yú)");

}

@Override

public void setName(String name){

this.name = name;

}

@Override

public String getName(){

return this.name;

}

@Overrid

public void play(){

System.out.println("貓?jiān)谕婷€");

}

}

class Fish extends Animal implements Pet{

private String name;

protected Fish(){

super(0);

}

@Override

public void setName(String name){

this.name = name;

}

@Override

public String getName(){

return this.name;

}

@Override

public void walk(int legs){

System.out.println("魚(yú)沒(méi)有腿，只能游泳");

}

@Override

public void play(){

System.out.println("魚(yú)在水力追蝌蚪");

}

@Override

public void eat(){

System.out.println("魚(yú)吃草");

}

}

數(shù)字與字符串

拆箱裝箱基本數(shù)據(jù)類型及對(duì)應(yīng)封裝類

基本數(shù)據(jù)類型封裝類byteByteshortShortintIntegerlongLongfloatFloatdoubleDoublecharCharacterbooleanBoolean

graph TD

A[Number] --- B[Byte]

A[Number] --- C[Short]

A[Number] --- D[Integer]

A[Number] --- E[Long]

A[Number] --- F[Float]

A[Number] --- G[Double]自動(dòng)裝箱：無(wú)需調(diào)用構(gòu)造方法，通過(guò) = 自動(dòng)把 基本類型轉(zhuǎn)換為封裝類 的過(guò)程叫做自動(dòng)裝箱；

自動(dòng)拆箱 ：無(wú)需調(diào)用對(duì)應(yīng)方法，通過(guò) = 自動(dòng)將 封裝類轉(zhuǎn)換為基本類型 的過(guò)程叫做自動(dòng)拆箱；

int 類型的最大最小值 ： 最大值 ：Integer.MAX_VALUE；最小值 ：Integer.MIN_VALUE；

public class TestNumber{

public static void main(String[] args) throws Exception{

byte byteNum1 = 3;

// 自動(dòng)裝箱

Byte byteNumClass1 = byteNum1;

// 自動(dòng)拆箱

Byte byteNumClass2 = new Byte(byteNum1);

byte byteNum2 = byteNumClass2;

}

}

字符串轉(zhuǎn)換

數(shù)字轉(zhuǎn)字符串使用 String 類的靜態(tài)方法 valueOf；

現(xiàn)將基本類型封裝成對(duì)象，然后調(diào)用 toString 方法；

通過(guò) + 將數(shù)字與 “” 相連；

public class Demo{

public void main(String[] args) throws Exception{

int num = 200;

// 方法 1

String numString1 = String.valueOf(num);

// 方法 2

Integer numClass = new Integer(num);

String numString2 = numClass.toString();

// 方法 3

String numString3 = num + "";

}

}

字符串轉(zhuǎn)數(shù)字通過(guò)各個(gè)封裝類的靜態(tài)方法 parseXxx 進(jìn)行裝換；

public class Demo{

public void main(String[] args) throws Exception{

String numString1 = "34";

int num1 = Integer.parseInt(numString1);

String numString2 = "35.34";

float num2 = Float.parseFloat(numString2);

}

}

格式化輸出

字符含義%s字符串%d數(shù)字%n換行(平臺(tái)無(wú)關(guān))

public class TestNumber {

public static void main(String[] args) {

String name ="迦羅";

int kill = 8;

String title="超神";

String sentenceFormat ="%s 在進(jìn)行了連續(xù) %d 次擊殺后，獲得了 %s 的稱號(hào)%n";

// printf 和 format 效果一樣

//使用printf格式化輸出

System.out.printf(sentenceFormat,name,kill,title);

//使用format格式化輸出

System.out.format(sentenceFormat,name,kill,title);

}

}換行符DOS 和 Windows 中，每行結(jié)尾是 \r\n；

Linux 中，每行結(jié)尾是 \n；

Mac 中，每行結(jié)尾是 \r；

常用格式化方式

import java.util.Locale;

public class TestNumber {

public static void main(String[] args) throws Exception{

int year = 2020;

//總長(zhǎng)度，左對(duì)齊，補(bǔ)0，千位分隔符，小數(shù)點(diǎn)位數(shù)，本地化表達(dá)

//直接打印數(shù)字

System.out.format("%d%n",year);

//總長(zhǎng)度是8,默認(rèn)右對(duì)齊

System.out.format("%8d%n",year);

//總長(zhǎng)度是8,左對(duì)齊

System.out.format("%-8d%n",year);

//總長(zhǎng)度是8,不夠補(bǔ)0

System.out.format("%08d%n",year);

//千位分隔符

System.out.format("%,8d%n",year*10000);

//小數(shù)點(diǎn)位數(shù)

System.out.format("%.2f%n",Math.PI);

//不同國(guó)家的千位分隔符

// 法國(guó)

System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);

// 美國(guó)

System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);

// 英國(guó)

System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);

}

}

字符串創(chuàng)建字符串的方式當(dāng)有一個(gè) 字面值 出現(xiàn)時(shí)，虛擬機(jī)自動(dòng)創(chuàng)建一個(gè)字符串；

調(diào)用 String 的構(gòu)造方法創(chuàng)建；

通過(guò)字符數(shù)組創(chuàng)建；

通過(guò) + 進(jìn)行字符串拼接；

public class TestString {

public static void main(String[] args) {

// 字面值創(chuàng)建

String garen ="蓋倫";

// 構(gòu)造方法創(chuàng)建

String teemo = new String("提莫");

// 通過(guò)字符數(shù)組創(chuàng)建

char[] cs = new char[]{'崔','斯','特'};

String hero = new String(cs);

// 通過(guò) + 加號(hào)進(jìn)行字符串拼接

String hero3 = garen + teemo;

}

}String 被 final 修飾，無(wú)法被繼承，而且一旦被創(chuàng)建就不可改變(不能增加長(zhǎng)度、不能減少長(zhǎng)度、不能插入字符、不能刪除字符、不能修改字符)；

常見(jiàn)方法

方法簡(jiǎn)介charAt(int index)獲取某索引位置字符toCharArray()將字符串轉(zhuǎn)換為字符數(shù)組subString(int start, int end)獲取索引位置在 [start, end) 的子字符串split(String str)根據(jù)分割符將字符串分割為字符串?dāng)?shù)組trim()去掉首尾空格toLowerCase()全部變成小寫(xiě)toUpperCase()全部變成大寫(xiě)indexOf字符或子字符串第一次出現(xiàn)的索引位置lastIndexOf字符或子字符串最后一次出現(xiàn)的索引位置contains字符串是否包含子字符串replaceAll用指定字符串替換目標(biāo)字符串replaceFirst用指定字符串替換第一個(gè)目標(biāo)字符串startsWith判斷字符串是否以子字符串開(kāi)始endsWith判斷字符串是否以子字符串結(jié)束字符串比較

用 == 比較字符串是否指向同一對(duì)象，equals() 方法比較字符串內(nèi)容是否一樣；

注意特例 ：

public class TestString {

public static void main(String[] args) {

String str1 = "the light";

String str2 = new String(str1);

// 用于判斷是否是同一個(gè)字符串對(duì)象

System.out.println( str1 == str2); // false

// 用于判斷是否是同一個(gè)字符串對(duì)象

System.out.println(str1.equals(str2)); // true

// 特例，當(dāng)編譯器遇到字符串字面值時(shí)，若發(fā)現(xiàn)有重復(fù)的，則會(huì)直接使用而不再重復(fù)創(chuàng)建

String str3 = "the light";

System.out.println( str1 == str3); // true

}

}

StringBuffer

StringBuffer 不同于 String，屬于可變長(zhǎng)的字符串，需要經(jīng)常操作字符串時(shí)，StringBuffer 性能更高，常用方法如下：

方法功能append追加delete刪除insert插入reverse反轉(zhuǎn)length內(nèi)容長(zhǎng)度capacity總空間

public class TestString {

public static void main(String[] args) {

String str1 = "let there ";

// 根據(jù)str1創(chuàng)建一個(gè)StringBuffer對(duì)象

StringBuffer sb = new StringBuffer(str1);

//在最后追加

sb.append("be light");

System.out.println(sb);

// 刪除4-10之間的字符

sb.delete(4, 10);

System.out.println(sb);

// 在4這個(gè)位置插入 there

sb.insert(4, "there ");

System.out.println(sb);

// 反轉(zhuǎn)

sb.reverse();

System.out.println(sb);

// 內(nèi)容長(zhǎng)度

System.out.println(sb.length());

// 總空間

System.out.println(sb.capacity());

}

}

日期

日期格式化SimpleDateFormat 類常用方法

方法功能format日期轉(zhuǎn)字符串parse字符串轉(zhuǎn)日期

import java.text.SimpleDateFormat;

import java.util.Date;

/**

* 日期轉(zhuǎn)字符串

*/

public class TestDate {

public static void main(String[] args) throws Exception{

//y 代表年

//M 代表月

//d 代表日

//H 代表24進(jìn)制的小時(shí)

//h 代表12進(jìn)制的小時(shí)

//m 代表分鐘

//s 代表秒

//S 代表毫秒

SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );

Date d= new Date();

String str = sdf.format(d);

System.out.println("當(dāng)前時(shí)間通過(guò) yyyy-MM-dd HH:mm:ss SSS 格式化后的輸出: "+str);

SimpleDateFormat sdf1 =new SimpleDateFormat("yyyy-MM-dd" );

Date d1= new Date();

String str1 = sdf1.format(d1);

System.out.println("當(dāng)前時(shí)間通過(guò) yyyy-MM-dd 格式化后的輸出: "+str1);

}

}

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class TestDate {

public static void main(String[] args) {

SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" );

String str = "2020/5/1 12:12:12";

try {

Date d = sdf.parse(str);

System.out.printf("字符串 %s 通過(guò)格式 yyyy/MM/dd HH:mm:ss %n轉(zhuǎn)換為日期對(duì)象: %s",str,d.toString());

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

總結(jié)

以上是生活随笔為你收集整理的java窗口how2j_How2J Java 基础的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。