JavaSE之类和对象

构造器

public class MethodDemo1 {
    // 特殊的方法：构造器（构造方法）
    // 1.这个方法名字 -- 必须和类名完全一样
    // 2.没有返回值，连void也写
    // 3.不能用static修饰
    public MethodDemo1() {
        System.out.println(123);
    }
    public MethodDemo1(int i) {
        
    }
    public static void main(String[] args) {
        Random r = new Random();
    }
}

创建对象

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

全局变量存在默认值

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);
        // 全局变量有默认值
        // 整型0，浮点型0.0，布尔false,字符型\u0000,引用数据类型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);
    }
}

对象类型数组

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};
//      遍历这个数组，打印出所有学员的详细信息
//      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);
        }
    }
}

匿名对象

public class Demo1 {    
    public void test1() {
        System.out.println(123);
    }
    public void test2() {
        System.out.println(456);
    }
    public static void main(String[] args) {
        // 匿名对象 : 没有引用指向的对象，它只能使用一次
//      Demo1 d = new Demo1();
//      d.test1();
//      d.test2();
        new Demo1().test1();
        new Demo1().test2();
        
        // 垃圾自动回收机制（GC）
        // JVM会把堆中没有引用指向的对象视为垃圾对象，当这个对象执行完对应的工作，JVM虚拟机
        // 会自动找到这些垃圾对象调用其finalize()回收内存
    }
}

this关键字

public class Demo3 {
    String name = "张三";
    // this : 代表当前类对象
    // ①this.属性名，this.方法()
    // ②this() : 只能用在构造器中，调用其他构造器，在一个构造器中只能用一次，并且必须在第一行使用   
    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);
    }
}

封装（四个访问权限修饰符）

public class Demo5 {
    public static void main(String[] args) {
        // Java面相对象特性：继承，封装，多态，抽象
        // 抽象（程序员将现实实物抽象为脑中概念模型）
        // 封装 ：将一套功能组织成一个方法，将一套方法加一套属性组织到一个类，将一套类组织到一个包中
        // 访问权限修饰符
        /*
         * public : 公有，工程中可见
         *      能修饰类，方法，属性（全局变量）
         * protected : 受保护的,当前包可见，跨包的“亲戚”可见，“非亲戚”不可见
         *      能修饰方法和属性
         * 【friendly,default】:默认的，跨包不可见
         *      能修饰类，方法，属性（全局变量）
         * private : 私有的，只有当前类可见
         *      能修饰方法和属性
         */
        // JavaBean(实体类) : 
        // 1.有无参构造器（必要）
        // 2.属性全部私有
        // 3.有公有的get（获取）和set（修改）方法
        
    }
}

控制台模拟植物大战僵尸

僵尸类

public class Zoombie {
    int hp = 500;
    int dps = 30;
    /**
     * 攻击
     * @param sf 向日葵对象
     */
    public void attack(SunFlower sf) {
        if(hp <= 0) {
            System.out.println("对不起，僵尸没血，无法攻击");
        }
        else {
            // 判断向日葵是否有血
            if(sf.hp <= 0) {
                System.out.println("向日葵没有血了，严禁鞭尸");
            }
            // 僵尸有hp，对方也有
            else {
                System.out.println("僵尸对向日葵造成了 "+dps+" 点伤害");
                // 对方掉血
                sf.hp = sf.hp - dps;
                // 如果是负数，归0
                if(sf.hp <= 0) {
                    sf.hp = 0;
                    System.out.println("向日葵已经死亡");
                    return;
                }
                System.out.println("向日葵还剩 "+sf.hp+" 点血量");
            }
        }
    }
    public void attack(BeanHunter bh) {
        if(hp <= 0) {
            System.out.println("对不起，僵尸没血，无法攻击");
        }
        else {
            // 判断向日葵是否有血
            if(bh.hp <= 0) {
                System.out.println("豌豆射手没有血了，严禁鞭尸");
            }
            // 僵尸有hp，对方也有
            else {
                System.out.println("僵尸对豌豆射手造成了 "+dps+" 点伤害");
                // 对方掉血
                bh.hp = bh.hp - dps;
                // 如果是负数，归0
                if(bh.hp < 0) {
                    bh.hp = 0;
                }
                System.out.println("豌豆射手还剩 "+bh.hp+" 点血量");
            }
        }
    }
}

向日葵类

public class SunFlower {
    int hp = 300;
    /**
     * 回血方法
     */
    public void addBuff() {
        hp = hp + 20;
        if(hp > 300) {
            hp = 300;
        }
        System.out.println("向日葵进行了光合作用，回复了20点血，目前血量 "+hp);
    }
}

豌豆射手类

public class BeanHunter {
    int hp = 200;
    int dps = 60;
    public void attack(Zoombie z) {
        if(hp <= 0) {
            System.out.println("对不起，豌豆射手没血，无法攻击");
        }
        else {
            if(z.hp <= 0) {
                System.out.println("僵尸没有血了，严禁鞭尸");
            }
            else {
                System.out.println("豌豆射手对僵尸造成了 "+dps+" 点伤害");
                // 对方掉血
                z.hp = z.hp - dps;
                // 如果是负数，归0
                if(z.hp < 0) {
                    z.hp = 0;
                    System.out.println("僵尸GG了");
                    return;
                }
                System.out.println("僵尸还剩 "+z.hp+" 点血量");
            }
        }
    }
}

启动类

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;
            }
            // 互相伤害
            // 生成随机数
            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;// 点数
    public void giveMe() {
        String hs[] = {"红桃","黑桃","方片","草花"};
        String ds[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        // 写一个循环，生成一副扑克
        Poker pokers[] = new Poker[52];
        int index = 0;
        // 遍历数组，取到hs[]和ds[]的所有组合，给Poker对象赋值，然后存入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();
    }
}