java_SE类和对象

构造器

特殊的方法：构造器（构造方法）
1.这个方法名字 -- 必须和类名完全一样
2.没有返回值，连void也写
3.不能用static修饰

public class MethodDemo1 {
    public MethodDemo1() { //无参
        System.out.println(123);
    }
    public MethodDemo1(int i) { //有参
        
    }
    public static void main(String[] args) {
        Random r = new Random();
    }
}

全局变量

局部变量使用前必须赋值
全局变量有默认值

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关键字

this : 代表当前类对象
①this.属性名，this.方法()
②this() : 只能用在构造器中，调用其他构造器，在一个构造器中只能用一次，并且必须在第一行使用

public class Demo3 {
    String name = "张三";
    public Demo3() {
        this("李四");
        System.out.println(1);
    }
    public Demo3(String name) {
        this.name=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);
    }
}

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

Java面相对象特性：继承，封装，多态，抽象
抽象（程序员将现实实物抽象为脑中概念模型）
封装 ：将一套功能组织成一个方法，将一套方法加一套属性组织到一个类，将一套类组织到一个包中
访问权限修饰符
/*

• public : 公有，工程中可见

•  能修饰类，方法，属性（全局变量）
  

• protected : 受保护的,当前包可见，跨包的“亲戚”可见，“非亲戚”不可见

•  能修饰方法和属性
  

• 【friendly,default】:默认的，跨包不可见

•  能修饰类，方法，属性（全局变量）
  

• private : 私有的，只有当前类可见

•  能修饰方法和属性
  

*/
JavaBean(实体类) :
1.有无参构造器（必要）
2.属性全部私有
3.有公有的get（获取）和set（修改）方法

public class Student {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

//单例模式：

保证一个类只能有一个实例（一个类只能创建一个对象）
/*
* 1.：如何解决多例（不能让其他类随意使用构造器）
* 构造器私有
private Singletion() {}
* 2.：如何解决提供一个实例
* 在当前位置创建一个实例
static Singletion singletion = new Singletion();
* 3.:不能随意修改
* 将创建的实例也私有
private static Singletion singletion = new Singletion();
* 4.:如何获取这个实例
* 提供一个public的方法将这个实例反出去
* */
懒汉模式（懒加载），调用的时候就创建，不调用就不创建

    private static Singletion singletion;
    public static Singletion getSingletion() {
        if(singletion == null) {
            singletion=new Singletion();
        }
        return singletion;
    }

饿汉模式

private static Singletion singletion = new Singletion();
    public static Singletion getSingletion() {
        return singletion;
    }

生成一副扑克牌

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.print(p.suit+p.count+" ");
            System.out.println();
        }
    }
    public static void main(String[] args) {
        Poker p = new Poker();
        p.giveMe();
    }
}

控制台模拟植物大战僵尸

僵尸类：

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