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