構(gòu)造器

public class MethodDemo1 {
    // 特殊的方法：構(gòu)造器（構(gòu)造方法）
    // 1.這個(gè)方法名字 -- 必須和類名完全一樣
    // 2.沒(méi)有返回值，連void也寫
    // 3.不能用static修飾
    public MethodDemo1() {
        System.out.println(123);
    }
    public MethodDemo1(int i) {
        
    }
    public static void main(String[] args) {
        Random r = new Random();
    }
}

創(chuàng)建對(duì)象

public class ClassDemo2 {
    String name;
    public int getNum() {
        return 1;
    }
    public void showInfo(String n) {
        System.out.println(n+"你好");
    }
    public double getDouble(double num1,double num2) {
        return num1/num2;
    }
}

public class ClassDemo2Test {
    public static void main(String[] args) {
        ClassDemo2 cd = new ClassDemo2();
        cd.name = "張三";
        cd.showInfo("老師");
        int num = cd.getNum();
        System.out.println(num);
        double num1 = cd.getDouble(5.3, 1.1);
        System.out.println(num1);
    }
}

全局變量存在默認(rèn)值

public class ClassDemo3Test {
    public static void main(String[] args) {
        // 局部變量使用前必須賦值
//      String str;
//      System.out.println(str);
        ClassDemo3 cd = new ClassDemo3();
        System.out.println(cd.name);
        cd.name = "李四";
        System.out.println(cd.name);
        // 全局變量有默認(rèn)值
        // 整型0，浮點(diǎn)型0.0，布爾false,字符型\u0000,引用數(shù)據(jù)類型null
        cd.show();
        System.out.println(cd.age);
        
        ClassDemo3 cd1 = new ClassDemo3();
        cd1.name = "王五";
        cd1.show();
    }
}

就近原則

public class ClassDemo4 {
    String name;
    // 就近原則
    public void show(String name) {
        System.out.println(name);
    }
    
    public void test() {
        show("趙六");
        System.out.println(name);
    }
}

對(duì)象類型數(shù)組

public class ClassDemo6 {
    public static void main(String[] args) {
        int num = 10;
        int arr[] = {num};
        Student s1 = new Student("zhangsan","man",22);
        Student s2 = new Student("lishi","woman",32);
        Student s3 = new Student("wanghu","man",66);
        Student s[] = {s1,s2,s3};
//      遍歷這個(gè)數(shù)組，打印出所有學(xué)員的詳細(xì)信息
//      for(int i = 0;i < s.length;i++) {
//          Student stu = s[i];
//          System.out.println(stu.name);
//      }
        for(Student stu : s) {
            System.out.println(stu.name+","+stu.gender+","+stu.age);
        }
    }
}

匿名對(duì)象

public class Demo1 {    
    public void test1() {
        System.out.println(123);
    }
    public void test2() {
        System.out.println(456);
    }
    public static void main(String[] args) {
        // 匿名對(duì)象 : 沒(méi)有引用指向的對(duì)象，它只能使用一次
//      Demo1 d = new Demo1();
//      d.test1();
//      d.test2();
        new Demo1().test1();
        new Demo1().test2();
        
        // 垃圾自動(dòng)回收機(jī)制（GC）
        // JVM會(huì)把堆中沒(méi)有引用指向的對(duì)象視為垃圾對(duì)象，當(dāng)這個(gè)對(duì)象執(zhí)行完對(duì)應(yīng)的工作，JVM虛擬機(jī)
        // 會(huì)自動(dòng)找到這些垃圾對(duì)象調(diào)用其finalize()回收內(nèi)存
    }
}

this關(guān)鍵字

public class Demo3 {
    String name = "張三";
    // this : 代表當(dāng)前類對(duì)象
    // ①this.屬性名，this.方法()
    // ②this() : 只能用在構(gòu)造器中，調(diào)用其他構(gòu)造器，在一個(gè)構(gòu)造器中只能用一次，并且必須在第一行使用   
    public Demo3() {
        this("lisi");
        System.out.println(1);
    }
    public Demo3(String name) {
        System.out.println(123);
    }
//  public void show() {
//      String name = "李四";
//      System.out.println(name);
//      System.out.println(this.name);
//      test();
//  }
//  public void test() {
//      System.out.println(123);
//  }
    public static void main(String[] args) {
        Demo3 d = new Demo3();
        d.name = "1";
        Demo3 d1 = new Demo3();
        d1.name = "1";
        System.out.println(d.name);
    }
}

封裝（四個(gè)訪問(wèn)權(quán)限修飾符）

public class Demo5 {
    public static void main(String[] args) {
        // Java面相對(duì)象特性：繼承，封裝，多態(tài)，抽象
        // 抽象（程序員將現(xiàn)實(shí)實(shí)物抽象為腦中概念模型）
        // 封裝 ：將一套功能組織成一個(gè)方法，將一套方法加一套屬性組織到一個(gè)類，將一套類組織到一個(gè)包中
        // 訪問(wèn)權(quán)限修飾符
        /*
         * public : 公有，工程中可見(jiàn)
         *      能修飾類，方法，屬性（全局變量）
         * protected : 受保護(hù)的,當(dāng)前包可見(jiàn)，跨包的“親戚”可見(jiàn)，“非親戚”不可見(jiàn)
         *      能修飾方法和屬性
         * 【friendly,default】:默認(rèn)的，跨包不可見(jiàn)
         *      能修飾類，方法，屬性（全局變量）
         * private : 私有的，只有當(dāng)前類可見(jiàn)
         *      能修飾方法和屬性
         */
        // JavaBean(實(shí)體類) : 
        // 1.有無(wú)參構(gòu)造器（必要）
        // 2.屬性全部私有
        // 3.有公有的get（獲?。┖蛃et（修改）方法
        
    }
}

控制臺(tái)模擬植物大戰(zhàn)僵尸

僵尸類

public class Zoombie {
    int hp = 500;
    int dps = 30;
    /**
     * 攻擊
     * @param sf 向日葵對(duì)象
     */
    public void attack(SunFlower sf) {
        if(hp <= 0) {
            System.out.println("對(duì)不起，僵尸沒(méi)血，無(wú)法攻擊");
        }
        else {
            // 判斷向日葵是否有血
            if(sf.hp <= 0) {
                System.out.println("向日葵沒(méi)有血了，嚴(yán)禁鞭尸");
            }
            // 僵尸有hp，對(duì)方也有
            else {
                System.out.println("僵尸對(duì)向日葵造成了 "+dps+" 點(diǎn)傷害");
                // 對(duì)方掉血
                sf.hp = sf.hp - dps;
                // 如果是負(fù)數(shù)，歸0
                if(sf.hp <= 0) {
                    sf.hp = 0;
                    System.out.println("向日葵已經(jīng)死亡");
                    return;
                }
                System.out.println("向日葵還剩 "+sf.hp+" 點(diǎn)血量");
            }
        }
    }
    public void attack(BeanHunter bh) {
        if(hp <= 0) {
            System.out.println("對(duì)不起，僵尸沒(méi)血，無(wú)法攻擊");
        }
        else {
            // 判斷向日葵是否有血
            if(bh.hp <= 0) {
                System.out.println("豌豆射手沒(méi)有血了，嚴(yán)禁鞭尸");
            }
            // 僵尸有hp，對(duì)方也有
            else {
                System.out.println("僵尸對(duì)豌豆射手造成了 "+dps+" 點(diǎn)傷害");
                // 對(duì)方掉血
                bh.hp = bh.hp - dps;
                // 如果是負(fù)數(shù)，歸0
                if(bh.hp < 0) {
                    bh.hp = 0;
                }
                System.out.println("豌豆射手還剩 "+bh.hp+" 點(diǎn)血量");
            }
        }
    }
}

向日葵類

public class SunFlower {
    int hp = 300;
    /**
     * 回血方法
     */
    public void addBuff() {
        hp = hp + 20;
        if(hp > 300) {
            hp = 300;
        }
        System.out.println("向日葵進(jìn)行了光合作用，回復(fù)了20點(diǎn)血，目前血量 "+hp);
    }
}

豌豆射手類

public class BeanHunter {
    int hp = 200;
    int dps = 60;
    public void attack(Zoombie z) {
        if(hp <= 0) {
            System.out.println("對(duì)不起，豌豆射手沒(méi)血，無(wú)法攻擊");
        }
        else {
            if(z.hp <= 0) {
                System.out.println("僵尸沒(méi)有血了，嚴(yán)禁鞭尸");
            }
            else {
                System.out.println("豌豆射手對(duì)僵尸造成了 "+dps+" 點(diǎn)傷害");
                // 對(duì)方掉血
                z.hp = z.hp - dps;
                // 如果是負(fù)數(shù)，歸0
                if(z.hp < 0) {
                    z.hp = 0;
                    System.out.println("僵尸GG了");
                    return;
                }
                System.out.println("僵尸還剩 "+z.hp+" 點(diǎn)血量");
            }
        }
    }
}

啟動(dòng)類

public class Test {
    public static void main(String[] args) {
        Zoombie z = new Zoombie();
        SunFlower sf = new SunFlower();
        BeanHunter bh = new BeanHunter();
        
        while(true) {
            if(z.hp <= 0) {
                System.out.println("植物勝利");
                break;
            }
            if(sf.hp <= 0 && bh.hp <= 0) {
                System.out.println("僵尸勝利");
                break;
            }
            // 互相傷害
            // 生成隨機(jī)數(shù)
            double random = Math.random();// [0,1)
            if(random <= 0.3) {
                z.attack(sf);
            }else if(random <= 0.5) {
                z.attack(bh);
            }else if(random <= 0.8) {
                bh.attack(z);
            }else {
                sf.addBuff();
            }   
            try {
                Thread.sleep(1000);// 休眠1000毫秒，即1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生成一副撲克牌

public class Poker {
    String suit;// 花色
    String count;// 點(diǎn)數(shù)
    public void giveMe() {
        String hs[] = {"紅桃","黑桃","方片","草花"};
        String ds[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        // 寫一個(gè)循環(huán)，生成一副撲克
        Poker pokers[] = new Poker[52];
        int index = 0;
        // 遍歷數(shù)組，取到hs[]和ds[]的所有組合，給Poker對(duì)象賦值，然后存入pokers[]
        for(int i = 0;i < hs.length;i++) {
            for(int j = 0;j < ds.length;j++) {
                pokers[index] = new Poker();
                pokers[index].suit = hs[i];
                pokers[index].count = ds[j];
                index++;
            }
        }
        for(Poker p : pokers) {
            System.out.println(p.suit+p.count);
        }
    }
    public static void main(String[] args) {
        Poker p = new Poker();
        p.giveMe();
    }
}