java窗口how2j_How2J Java 基础
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>
類和對象
public class Item{
// 物品名
String name;
// 價格
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 = "長劍";
sword.price = 530;
}
}
方法
public class Item{
// 物品名
String name;
// 價格
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 個字節(jié)，8 位
short，2 個字節(jié)， 16 位
int，4 個字節(jié)，32 位
long，8 個字節(jié)，64 位
浮點型float，4 個字節(jié)，32 位
double，8 個字節(jié)，64 位字符型char，2 個字節(jié)，16 位
布爾型boolean，1 位
字面值
給基本數(shù)據(jù)類型變量賦值的方式叫做 字面值；
類型轉(zhuǎn)換
轉(zhuǎn)換規(guī)則
從小達(dá)到自動轉(zhuǎn)，從大到小強(qiáng)制轉(zhuǎn)；高精度向低精度轉(zhuǎn)換，可能導(dǎo)致溢出；
低精度可以向高精度轉(zhuǎn)換；
不同數(shù)據(jù)類型之間相互轉(zhuǎn)換需要進(jìn)行 強(qiáng)制轉(zhuǎn)換；
命名規(guī)則及建議變量命名只能使用 字母、數(shù)字、_、$；
變量第一個字符只能 字母、$、_，不能是 數(shù)字；
變量命名不能使用關(guān)鍵字，但可以包含關(guān)鍵字；
盡量使用完整單詞，而非縮寫；
塊
Java 中 {} 包括的部分，稱為一個塊；
作用域字段、屬性、Field
當(dāng)變量聲明在 類下 時，叫做 字段，或者 屬性、成員變量、Field，作用域 從聲明的位置開始的整個類；參數(shù)
當(dāng)變量聲明在 方法上 時，叫做 參數(shù)，作用域為 該方法內(nèi)所有代碼，其他方法和類都不能訪問；局部變量
當(dāng)變量聲明在 方法內(nèi) 時，叫做 局部變量，作用域為 從聲明的位置開始，直到所處于的塊結(jié)束；
final 修飾符
當(dāng)聲明一個用 final 修飾的變量時，說明該變量 有且只有一次賦值的機(jī)會；
操作符
算數(shù)操作符+、-、×、/、%、++、--
當(dāng)不同的運(yùn)算單元(任一長度超過 int)進(jìn)行運(yùn)算時，最終返回結(jié)果按照最長的長度計算；
當(dāng)不同的運(yùn)算單元(任一長度不超過 int)進(jìn)行運(yùn)算時，最終返回結(jié)果按照 int 計算；
++、-- 前置時，先運(yùn)算，再取值；后置時、先取值，再計算；
關(guān)系操作符>、>=、
邏輯操作符&、&&、|、||、！、^
長路與短路的區(qū)別：長路會運(yùn)算符兩邊的值均進(jìn)行運(yùn)算，短路當(dāng)運(yùn)算符左側(cè)為 false 時，運(yùn)算符右側(cè)則不再計算；
位運(yùn)算符Integer.toBinaryString()、|、&、^、～、<>、>>>
>> 與 >>> 的區(qū)別>> 會將正數(shù)所有位右移，并在最前面補(bǔ) 0，會將負(fù)數(shù)所有位右移，并在最前面補(bǔ) 1；
>>> 會將負(fù)數(shù)的二進(jìn)制的第一位的 1 也向右移動，然后在前面補(bǔ) 0，從而導(dǎo)致負(fù)數(shù)在無符號右移后，得到一個正數(shù)；
>> 移動后數(shù)的正負(fù)性不變，>>> 移動后變?yōu)檎龜?shù)；
三元操作符表達(dá)式?值1:值2，當(dāng)表達(dá)式為真時，返回值 1；當(dāng)表達(dá)式為假時，返回值 2；
控制流程
switchswitch 中可以使用 byte、short、int、char、String、enum；
每個表達(dá)式結(jié)束都應(yīng)該有一個 break；
使用 String 的實質(zhì)還是使用正數(shù)，是通過編譯后將其轉(zhuǎn)化為 hash 值；
數(shù)組
創(chuàng)建數(shù)組數(shù)組是一個 長度固定，包含 相同類型 數(shù)據(jù)的 容器；
若一個變量代表一個數(shù)組，則將這個變量叫做 引用；
// 聲明一個引用
int[] arr;
// 創(chuàng)建一個長度為 10 的數(shù)組，且使用引用 arr 指向該數(shù)組
初始化數(shù)組分配空間與賦值同步
//分配長度為 5 的數(shù)組，但未賦值
int[] a = new int[5];
//沒有賦值，那么就會使用默認(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;分配空間同時賦值
// 方式 1，分配空間同時賦值
int[] arr1 = new int[]{100,102,444,836,3236};
// 方式 2
int[] arr2 = {100,102,444,836,3236};
// 方式 3，分配空間的同時指定內(nèi)容
int[] arr3 = neew int[5]{100,102,444,836,3236};
數(shù)組排序
選擇排序思路
首先在未排序數(shù)組中找到最小元素，存放到排序數(shù)組的其實位置，然后再從剩余未排序的元素中尋找最小的元素，放到排序數(shù)組起始位置，以此類推直到數(shù)組所有元素排序完畢；實現(xiàn)
/**
* 選擇排序
* @param source 未排序數(shù)組
*/
public void selectSort(int[] source){
// 數(shù)組長度
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;
}
}
}
}
冒泡排序思路
通過雙層循環(huán)，內(nèi)層循環(huán)將相鄰的兩個數(shù)進(jìn)行比較，將最大的一個數(shù)以冒泡(兩兩交換)的形式傳送到數(shù)組尾部，每次將一個最大值傳到數(shù)組尾部，外層循環(huán)則實現(xiàn)依次將當(dāng)前最大值傳送，最終實現(xiàn)排序；實現(xiàn)
/**
* 冒泡排序
* @param source 未排序數(shù)組
*/
public void bubbleSort(int[] source){
// 數(shù)組長度
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ù)組進(jìn)行復(fù)制；將一個數(shù)組的值復(fù)制到另一個數(shù)組
/**
* @param src 源數(shù)組
* @param srcPos 源數(shù)組要復(fù)制的起始位置
* @param dest 目的數(shù)組
* @param destPos 目的數(shù)組要放置的起始位置
* @param length 復(fù)制的長度
*/
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
* 公眾號 : 村雨遙
* 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
* 公眾號 : 村雨遙
* Date : 2020/5/6 下午1:27
* Project : mavenDemo
* Package : PACKAGE_NAME
* Class : ArraysOperation
* Desc : Arrays 常見操作
*/
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));
}
}
類和對象
繼承
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)造方法
通過一個類構(gòu)建一個對象的過程叫做 實例化，而實例化是通過 構(gòu)造方法 來實現(xiàn)的；構(gòu)造方法名和類名一樣，但是 沒有返回類型，默認(rèn)會提夠一個無參的構(gòu)造方法，this 代表當(dāng)前對象；
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;
}
}
訪問修飾符常用修飾符
符號說明private私有package/friendly/default默認(rèn)，protected受保護(hù)public公有修飾符作用域
自身同包子類不同包子類同包類其他類private訪問不能繼承不能繼承無法訪問無法訪問package/friendly/default訪問繼承不能繼承訪問無法訪問protected訪問繼承繼承訪問無法訪問public訪問繼承繼承訪問訪問修飾符使用場景屬性通常用 private 封裝；
方法一般用 public 方便調(diào)用；
會被繼承的方法，通常用 protected ；
package 使用較少；
原則：作用范圍盡量小；
類屬性定義：當(dāng)類中一個屬性被 static 修飾時，叫做 類屬性，也叫 靜態(tài)屬性，當(dāng)一個屬性被聲明為類屬性時，所有對象均共享一個值；
對象屬性 ：又叫 實例屬性，非靜態(tài)屬性；
對象屬性與類屬性的對比 ：不同對象的 對象屬性的值 都可能不一樣，但所有對象的 類屬性的值 都是一樣的；
若一個屬性對所有對象都不一樣，則該屬性應(yīng)該設(shè)計為 對象屬性，因為它 跟著對象走；
若一個對象被所有對象共享，均一樣，則該屬性應(yīng)該被設(shè)計為 類屬性；
訪問方式對象.類屬性 ：teemo.hp ；
類.類屬性 ：Hero.hp ，推薦使用；
類方法類方法 ：又叫做 靜態(tài)方法，被 static 修飾的方法，訪問類方法，無需對象 存在就可以直接訪問，若某一方法中 未調(diào)用任何對象屬性，則可以設(shè)計為類方法；
對象方法 ：又叫 實例方法，非靜態(tài)方法，訪問一個對象方法，必須建立在 有一個對象 的前提上，若某一方法中 訪問了對象屬性，則該方法 必須 設(shè)計為對象方法；
類方法調(diào)用方式：對象.類方法 ：teemo.die() ；
類.類方法 ：Hero.battleWin() ，推薦使用；
屬性初始化對象屬性初始化方式 ：聲明該屬性時初始化；
構(gòu)造方法中初始化；
初始化塊;
public class Hero{
// 聲明同時初始化
public String name = "teemo";
protected float hp;
float maxHP;
// 初始化塊初始化
{
maxHP = 999;
}
// 構(gòu)造方法中初始化
public Hero(){
hp = 100;
}
}類屬性初始化方式 ：聲明該屬性時初始化；
靜態(tài)初始化塊；
public class Hero{
public String name;
protected float hp;
float maxHP;
// 聲明時初始化
public static int itemCapacity = 10;
// 靜態(tài)初始化塊
static{
itemCapacity = 20;
}
}屬性初始化塊的執(zhí)行順序：
靜態(tài)初始化塊 -> 非靜態(tài)初始化塊 ->構(gòu)造方法 ；
單例模式定義 : 又叫 Singleton 模式，指在一個類在 JVM 中，只存在一個實例；
單例模式分類：餓漢式 ： 無論如何都會創(chuàng)建一個實例，通過 public static 的 getInstance 方法獲取一個對象，每次獲取的都是同一個對象，屬于 立即加載，無論是否用到該對象，均加載；
懶漢式 ：只有在調(diào)用 getInstance 方法時才會創(chuàng)建實例，每次獲取的都是同一個對象，屬于 延遲加載，只有在使用該對象時才加載，同時具有 線程安全；
單例模式三要素 ：構(gòu)造方法私有化 ；
靜態(tài)屬性指向?qū)嵗?；
public staic 的 getInstance 方法，**返回上一個要素中的靜態(tài)屬性 ** ；
/**
* 餓漢式
*/
public class Earth{
// 私有構(gòu)造方法，使得無法在外部通過 new 實例化
private Earth(){
}
// 定義類屬性同時初始化
private static Earth instance = new Earth();
// private static 方法，用于獲取對象
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)造方法，使得無法在外部通過 new 實例化
private Earth(){
}
// 定義類屬性
private static Earth instance;
// private static 方法，用于獲取對象
public static Earth getInstance(){
// instance 未指向任何對象，將其實例化
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)
}
}
枚舉類型枚舉是一種特殊的類，方便定義常量，一般都是全大寫；
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);
}
}
}
接口與繼承
接口接口 無法用于實例化；
接口 無構(gòu)造方法；
接口中的 方法均為抽象方法；
無法包含成員變量，除了 static 和 final 變量；
接口支持多繼承；
對象轉(zhuǎn)型
向上轉(zhuǎn)型(子類轉(zhuǎn)父類、實現(xiàn)類轉(zhuǎn)接口)
Hero hero = new Hero();
AdHero ad = new AdHero();
hero = ad;
向下轉(zhuǎn)型(父類轉(zhuǎn)子類、接口轉(zhuǎn)實現(xiàn)類)
Hero hero = new Hero();
AdHero ad = new AdHero();
ad = (AdHero)hero;
重寫
子類可以繼承父類對象方法，繼承后重復(fù)提供該方法，則叫做 方法的重寫，也叫覆寫(override)；
class Item{
String name;
int price;
public void buy(){
System.out.println("購買");
}
public void effect(){
System.out.println("物品使用后生效");
}
}
public class LifePotion extends Item{
@override
public void effect(){
System.out.println("血瓶使用后回血");
}
}
多態(tài)操作符的多態(tài) ：同一操作符在不同情景下具有不同作用，如 + 兩側(cè)是整形，則代表 數(shù)字相加；若其中任意一個是字符串，則代表 字符串連接；
類的多態(tài)需要具備的條件 ：父類(接口)引用指向子類對象 ；
調(diào)用的方法經(jīng)歷重寫；
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 被擊殺");
}
}
隱藏定義 ：父類和子類擁有相同名字的屬性或方法時，父類的同名屬性或方法形式上不見了，但實際仍存在；即對于被隱藏的屬性和方法，不會被覆蓋，當(dāng)父類引用指向子類對象時，調(diào)用的隱藏屬性或方法仍然是父類的，而不會發(fā)生動態(tài)綁定；
public class Test {
public static void main(String[] args) {
Circle circle = new Circle();//本類引用指向本類對象
Shape shape = new Circle();//父類引用指向子類對象(會有隱藏和覆蓋)
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");
}
//對父類實例方法的覆蓋
public void printType() {
System.out.println("this is circle");
}
//對父類靜態(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)前對象的字符串表達(dá) ；
finalize()
當(dāng)一個對象沒有任何引用指向的時候，就滿足垃圾回收的條件，當(dāng)被垃圾回收時，其 finalize() 方法就會 被虛擬機(jī) JVM 調(diào)用，此時無需開發(fā)人員主動調(diào)用；
equals()
用于判斷兩個對象內(nèi)容是否相同；
==
不屬于 Object 類的方法，用于判斷兩個對象是否相同(即判斷兩個引用是否指向同一對象)；
hashCode()
用于返回一個對象的哈希值；
getClass()
返回一個對象的 類對象，主要用于 反射機(jī)制；
final修飾類 ：final 修飾類時，表示當(dāng)前類不允許繼承；
修飾方法 ：final 修飾方法時，表示該方法不允許被重寫；
修飾基本類型變量 ：final 修飾基本類型變量時，表示該變量只有一次賦值機(jī)會；
修飾引用 ：final 修飾引用時，表示該引用只有一次指向?qū)ο蟮臋C(jī)會；
抽象類定義：在類中聲明一個方法，該方法無具體實現(xiàn)，是一個 “空” 方法，則該方法叫做抽象方法，用 abstract 修飾；而當(dāng)一個類有抽象方法時，該類必須被聲明為 抽象類，抽象類不能直接實例化；
接口與抽象類的區(qū)別 ：子類 可以實現(xiàn)多個接口，但只能繼承一個抽象類；
抽象類可以定義 public、package、protected、private、靜態(tài)和非靜態(tài)屬性、final 和非 final 屬性，但 接口中聲明的屬性只能是 public、靜態(tài)、final；
內(nèi)部類可以分為如下 4 類：非靜態(tài)內(nèi)部類 ：直接定義在一個類中，可以直接訪問外部類的 private 屬性，內(nèi)部類實例化語法：內(nèi)部類 對象名 = new 外部類().new 內(nèi)部類();；
靜態(tài)內(nèi)部類 ：在一個類中聲明一個靜態(tài)內(nèi)部類，不能訪問外部類的實例屬性和方法，只能訪問外部類私有靜態(tài)成員，不需要一個外部類的實例為基礎(chǔ)，可以直接實例化，語法如下： 外部類.靜態(tài)內(nèi)部類 對象名 = 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)部類不能直接訪問外部類的對象屬性
System.out.println(name + " win this game");
}
}
}
public static void main(String[] args) {
//實例化靜態(tài)內(nèi)部類
Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
crystal.checkIfVictory();
}
}匿名類 ：在 聲明一個類的同時實例化，使用外部局部變量時，該變量必修修飾為 final；
package charactor;
public abstract class Hero {
String name; //姓名
float hp; //血量
float armor; //護(hù)甲
int moveSpeed; //移動速度
public abstract void attack();
public static void main(String[] args) {
ADHero adh=new ADHero();
//通過打印adh，可以看到adh這個對象屬于ADHero類
adh.attack();
System.out.println(adh);
Hero h = new Hero(){
//當(dāng)場實現(xiàn)attack方法
public void attack() {
System.out.println("新的進(jìn)攻手段");
}
};
h.attack();
//通過打印h，可以看到h這個對象屬于Hero$1這么一個系統(tǒng)自動分配的類名
System.out.println(h);
}
}本地類 ：可以看作是 帶名字的匿名類，匿名類不同之處在于內(nèi)部類的是內(nèi)部類必須聲明在成員的位置，即與屬性和方法平等位置，而本地類和匿名類一樣，直接聲明在代碼塊，可以是任何地方；
package charactor;
public abstract class Hero {
String name; //姓名
float hp; //血量
float armor; //護(hù)甲
int moveSpeed; //移動速度
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("貓在吃魚");
}
@Override
public void setName(String name){
this.name = name;
}
@Override
public String getName(){
return this.name;
}
@Overrid
public void play(){
System.out.println("貓在玩毛線");
}
}
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("魚沒有腿，只能游泳");
}
@Override
public void play(){
System.out.println("魚在水力追蝌蚪");
}
@Override
public void eat(){
System.out.println("魚吃草");
}
}
數(shù)字與字符串
拆箱裝箱基本數(shù)據(jù)類型及對應(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]自動裝箱：無需調(diào)用構(gòu)造方法，通過 = 自動把 基本類型轉(zhuǎn)換為封裝類 的過程叫做自動裝箱；
自動拆箱 ：無需調(diào)用對應(yīng)方法，通過 = 自動將 封裝類轉(zhuǎn)換為基本類型 的過程叫做自動拆箱；
int 類型的最大最小值 ： 最大值 ：Integer.MAX_VALUE；最小值 ：Integer.MIN_VALUE；
public class TestNumber{
public static void main(String[] args) throws Exception{
byte byteNum1 = 3;
// 自動裝箱
Byte byteNumClass1 = byteNum1;
// 自動拆箱
Byte byteNumClass2 = new Byte(byteNum1);
byte byteNum2 = byteNumClass2;
}
}
字符串轉(zhuǎn)換
數(shù)字轉(zhuǎn)字符串使用 String 類的靜態(tài)方法 valueOf；
現(xiàn)將基本類型封裝成對象，然后調(diào)用 toString 方法；
通過 + 將數(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ù)字通過各個封裝類的靜態(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換行(平臺無關(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 的稱號%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;
//總長度，左對齊，補(bǔ)0，千位分隔符，小數(shù)點位數(shù)，本地化表達(dá)
//直接打印數(shù)字
System.out.format("%d%n",year);
//總長度是8,默認(rèn)右對齊
System.out.format("%8d%n",year);
//總長度是8,左對齊
System.out.format("%-8d%n",year);
//總長度是8,不夠補(bǔ)0
System.out.format("%08d%n",year);
//千位分隔符
System.out.format("%,8d%n",year*10000);
//小數(shù)點位數(shù)
System.out.format("%.2f%n",Math.PI);
//不同國家的千位分隔符
// 法國
System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);
// 美國
System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);
// 英國
System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);
}
}
字符串創(chuàng)建字符串的方式當(dāng)有一個 字面值 出現(xiàn)時，虛擬機(jī)自動創(chuàng)建一個字符串；
調(diào)用 String 的構(gòu)造方法創(chuàng)建；
通過字符數(shù)組創(chuàng)建；
通過 + 進(jìn)行字符串拼接；
public class TestString {
public static void main(String[] args) {
// 字面值創(chuàng)建
String garen ="蓋倫";
// 構(gòu)造方法創(chuàng)建
String teemo = new String("提莫");
// 通過字符數(shù)組創(chuàng)建
char[] cs = new char[]{'崔','斯','特'};
String hero = new String(cs);
// 通過 + 加號進(jìn)行字符串拼接
String hero3 = garen + teemo;
}
}String 被 final 修飾，無法被繼承，而且一旦被創(chuàng)建就不可改變(不能增加長度、不能減少長度、不能插入字符、不能刪除字符、不能修改字符)；
常見方法
方法簡介charAt(int index)獲取某索引位置字符toCharArray()將字符串轉(zhuǎn)換為字符數(shù)組subString(int start, int end)獲取索引位置在 [start, end) 的子字符串split(String str)根據(jù)分割符將字符串分割為字符串?dāng)?shù)組trim()去掉首尾空格toLowerCase()全部變成小寫toUpperCase()全部變成大寫indexOf字符或子字符串第一次出現(xiàn)的索引位置lastIndexOf字符或子字符串最后一次出現(xiàn)的索引位置contains字符串是否包含子字符串replaceAll用指定字符串替換目標(biāo)字符串replaceFirst用指定字符串替換第一個目標(biāo)字符串startsWith判斷字符串是否以子字符串開始endsWith判斷字符串是否以子字符串結(jié)束字符串比較
用 == 比較字符串是否指向同一對象，equals() 方法比較字符串內(nèi)容是否一樣；
注意特例 ：
public class TestString {
public static void main(String[] args) {
String str1 = "the light";
String str2 = new String(str1);
// 用于判斷是否是同一個字符串對象
System.out.println( str1 == str2); // false
// 用于判斷是否是同一個字符串對象
System.out.println(str1.equals(str2)); // true
// 特例，當(dāng)編譯器遇到字符串字面值時，若發(fā)現(xiàn)有重復(fù)的，則會直接使用而不再重復(fù)創(chuàng)建
String str3 = "the light";
System.out.println( str1 == str3); // true
}
}
StringBuffer
StringBuffer 不同于 String，屬于可變長的字符串，需要經(jīng)常操作字符串時，StringBuffer 性能更高，常用方法如下：
方法功能append追加delete刪除insert插入reverse反轉(zhuǎn)length內(nèi)容長度capacity總空間
public class TestString {
public static void main(String[] args) {
String str1 = "let there ";
// 根據(jù)str1創(chuàng)建一個StringBuffer對象
StringBuffer sb = new StringBuffer(str1);
//在最后追加
sb.append("be light");
System.out.println(sb);
// 刪除4-10之間的字符
sb.delete(4, 10);
System.out.println(sb);
// 在4這個位置插入 there
sb.insert(4, "there ");
System.out.println(sb);
// 反轉(zhuǎn)
sb.reverse();
System.out.println(sb);
// 內(nèi)容長度
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)制的小時
//h 代表12進(jìn)制的小時
//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)前時間通過 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)前時間通過 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 通過格式 yyyy/MM/dd HH:mm:ss %n轉(zhuǎn)換為日期對象: %s",str,d.toString());
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
總結(jié)
以上是生活随笔為你收集整理的java窗口how2j_How2J Java 基础的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 如何将原图和json融合_图像语义分割出
- 下一篇： hashmap移除元素_Java Has