万字长文总结，带你重温 Java 基础

JAVA_HOME = /home/cunyu/soft/jdk-11.0.7
PATH = $JAVA_HOME/bin:$PATH

# 编译
javac HelloWorld.java

# 运行
java HelloWorld

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

// 声明一个引用
int[] arr;

// 创建一个长度为 10 的数组，且使用引用 arr 指向该数组

//分配长度为 5 的数组，但未赋值
int[] a = new int[5]; 

//没有赋值，那么就会使用默认值,作为int类型的数组，默认值是0
System.out.println(a[0]);

//进行赋值
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，分配空间的同时指定内容
int[] arr3 = neew int[5]{100,102,444,836,3236};

/**
* 选择排序
* @param source 未排序数组
*/

public void selectSort(int[] source){
    // 数组长度
    int size = source.lenth;
    for(int i = 0; i < size; i++){
        for(int j = i + 1; j < size; j++){
            // 进行交换，从小到大
            if(source[i] > source[j]){
            // 进行交换，从大到小
            // if(source[i] < source[j])
                int tmp = source[i];
                source[i] = source[j];
                source[j] = tmp;
            }
        }
    }
}

/**
* 冒泡排序
* @param source 未排序数组
*/

public void bubbleSort(int[] source){
    // 数组长度
    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;
            }
        }
    }
}

/**
* @param src 源数组
* @param srcPos 源数组要复制的起始位置
* @param dest 目的数组
* @param destPos 目的数组要放置的起始位置
* @param length 复制的长度
*/

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

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    : 合并数组
 */
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));
    }

    /**
     * 合并数组
     *
     * @param arr1    源数组 1
     * @param arr2    源数组 2
     * @param destArr 合并后的数组
     */
    public static void merge(int[] arr1, int[] arr2, int[] destArr) {
        // 将数组 1 合并到最终数组
        System.arraycopy(arr1, 0, destArr, 0, arr1.length);

        // 将数组 2 合并到最终数组
        System.arraycopy(arr2, 0, destArr, arr1.length, arr2.length);
    }
}

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

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

        // 转换为字符串
        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();
        
        // 布甲相关属性
        a1.name = "布甲";
        a1.price = 300;
        a1.hjdj =15;
        
        // 锁子甲相关属性
        a2.name = "锁子甲";
        a2.price = 500;
        a2.hjdj =40;
}

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

public class Hero{
    // 声明同时初始化
    public String name = "teemo";
    protected float hp;
    float maxHP;
    
    // 初始化块初始化
    {
        maxHP = 999;
    }
    
    // 构造方法中初始化
    public Hero(){
        hp = 100;
    }
}

public class Hero{
    
    public String name;
    protected float hp;
    float maxHP;
    
    // 声明时初始化
    public static int itemCapacity = 10;
    
    // 静态初始化块
    static{
        itemCapacity = 20;
    }
}

/**
* 饿汉式
*/

public class Earth{
    // 私有构造方法，使得无法在外部通过 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{
    // 私有构造方法，使得无法在外部通过 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);
        }
    }
}

Hero hero = new Hero();
AdHero ad = new AdHero();
hero = ad;

Hero hero = new Hero();
AdHero ad = new AdHero();
ad = (AdHero)hero;

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("血瓶使用后回血");
    }
}

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

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();
       //以上都是调用Circle类的方法和引用
       
        System.out.println(shape.name);//调用父类被隐藏的name属性
        shape.printType();//调用子类printType的方法
        shape.printName();//调用父类隐藏的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");
    }
    
   //对父类静态方法的隐藏  
    public static void printName() {
        System.out.println("circle");
    }
}

shape constructor
circle constructor
 
circle
this is circle
circle
 
shape
this is circle
shape

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("一次性");
            }
        }
    }
}

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("鱼吃草");
    }
}

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

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

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

public class TestNumber {
  
    public static void main(String[] args) {
 
        String name ="迦罗";
        int kill = 8;
        String title="超神";
         
        String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
        // printf 和 format 效果一样
        //使用printf格式化输出
        System.out.printf(sentenceFormat,name,kill,title);
        //使用format格式化输出
        System.out.format(sentenceFormat,name,kill,title);
         
    }
}

import java.util.Locale;

public class TestNumber {
   
    public static void main(String[] args) throws Exception{
        int year = 2020;
        //总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达
          
        //直接打印数字
        System.out.format("%d%n",year);
        //总长度是8,默认右对齐
        System.out.format("%8d%n",year);
        //总长度是8,左对齐
        System.out.format("%-8d%n",year);
        //总长度是8,不够补0
        System.out.format("%08d%n",year);
        //千位分隔符
        System.out.format("%,8d%n",year*10000);
  
        //小数点位数
        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);
          
    }
}

public class TestString {
 
    public static void main(String[] args) {
        // 字面值创建
        String garen ="盖伦"; 
        
        // 构造方法创建
        String teemo = new String("提莫"); 
         
        //  通过字符数组创建
        char[] cs = new char[]{'崔','斯','特'};
        String hero = new String(cs);
        
        // 通过 + 加号进行字符串拼接
        String hero3 = garen + teemo;
    }
}

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
        
        // 特例，当编译器遇到字符串字面值时，若发现有重复的，则会直接使用而不再重复创建
        String str3 = "the light";
        System.out.println( str1  ==  str3); // true
    }
 
}

public class TestString {
  
    public static void main(String[] args) {
        String str1 = "let there ";
 		
        // 根据str1创建一个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);
         
        // 反转
        sb.reverse();          
        System.out.println(sb);
        
        // 内容长度
        System.out.println(sb.length());
        
        // 总空间
        System.out.println(sb.capacity());
 
    }
  
}

import java.text.SimpleDateFormat;
import java.util.Date;

/**
* 日期转字符串
*/
public class TestDate {
  
    public static void main(String[] args) throws Exception{
          
        //y 代表年
        //M 代表月
        //d 代表日
        //H 代表24进制的小时
        //h 代表12进制的小时
        //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("当前时间通过 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("当前时间通过 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转换为日期对象: %s",str,d.toString());
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
          
    }
}