构造器
import java.util.Random;
public class MethodDome1 {
//特殊方法，构造器（构造方法）
// 1.这个方法名字必须与类名字相同
// 2.没有返回值，没有void
// 3.不能用static修饰
public void MethodDome1() {//普通方法
}
public MethodDome1() {//构造器不存在重载
System.out.println("123");
}
public static void main(String[] args) {
Random r=new Random();
}
}
创建对象
public class ClassDemoTest2 {
String name;
public int getNum() {
return 1;
}
public void show(String n) {
System.out.println(n+"nihao");
}
public double getDouble(double num,double num2){
return num/num2;
}
public static void main(String[] args) {
ClassDemoTest2 cd =new ClassDemoTest2();
cd.name="张三";
cd.show(cd.name);
int num =cd.getNum();
System.out.println(num);
double num1=cd.getDouble(5.3, 6.2);
System.out.println(num1);
}
}
public class ClassDemoTest3 {
public static void main(String[] args) {
//局部变量使用前必须赋值
ClassDemo3 cd= new ClassDemo3();
// 全局变量是有默认值的
// 整型0 浮点型0.0 布尔型 false 字符型\u0000 引用为null
cd.name="张三";
cd.show();
System.out.println(cd.age);
}
}
就近原则
public class ClassDemo4 {
String name;
// 就近原则
public void show(String name) {
System.out.println(name);
// System.out.println(this.name);//谁调用的就是谁
}
public void test() {
show("赵六");
}
}
对象类型的数组
public class ClassDemo6 {
public static void main(String[] args) {
// int num =10;
// int arr[]= {num};
Student s1 = new Student("礼哈","nan",596);
Student s2 = new Student("你","ijjoi",56);
Student s3 = new Student("好","ok",566);
Student s[]= {s1,s2,s3};
for(Student stu:s) {
System.out.println(stu.name+stu.gender+stu.age);
}
}
}
匿名对象
public class Demo1 {
public void test1() {
System.out.println("4554");
}
public void test2() {
System.out.println("444");
}
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 = "554";
//this.:当前类对象
// 1.this.属性名 2. this.方法（）
// this();只能用在构造器中，调用其他构造器
// ，在一个构造器中只能使用一次必须写在第一行
// public void show() {
// String name="李四";
// System.out.println(name);
// System.out.println(this.name);
// }
public Demo3() {
this("李四");
System.out.println("1112");
}
public Demo3(String name) {
this.name =name;
System.out.println("222");
}
public static void main(String[] args) {
Demo3 d = new Demo3();
System.out.println(d.name);
}
}
封装
ublic class Demo5 {
public static void main(String[] args) {
// java面向对象的特征：继承，封装，多态，
// 抽象（将现实事务抽象为脑中概念模型）
// 封装（hidden）：将一套功能组织成一个方法，将一套方法和一套属性组织到一个类，将一套类组织到一个包中
// 访问权限的修饰符：
// 1.public：
// 公有的，工程可见的，修饰所有的东西 类、方法、属性（全局变量）
// 2.protected （受保护的）： 挎包的“亲戚”可见
// 修饰方法和属性，不可修饰类
// 3.默认的（friendly，default） ： 挎包不可见
// 修饰所有的东西 类、方法、属性（全局变量）
// 4.private（私有的） ：当前的类可见
// 修饰方法和属性
// JavaBean（实体类）：
// 1.有无参构造器（必要）
// 2.属性全部私有
// 3.有公有的get（）方法和set（）方法
}
}
控制台模拟植物大战僵尸
僵尸类
ublic class Zoobie {
int hp=500;
int dps=30;
public void attack(SunFlower sf) {
if(hp<=0) {
System.out.print("僵尸没血了");
}else {
//判断向日葵是否有血
if(sf.hp<=0) {
System.out.println("对不去向日葵没有血了");
}
//僵尸有血，向日葵也有
else {
System.out.println("僵尸吗对向日葵已的伤害"+dps);
sf.hp=sf.hp-dps;
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.print("僵尸没血了");
}else {
if(bh.hp<=0) {
System.out.println("对不起射手没有血了");
}
//僵尸有血，向日葵也有
else {
System.out.println("僵尸吗对射手已的伤害"+dps);
bh.hp=bh.hp-dps;
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(Zoobie zb) {
if(hp<=0) {
System.out.print("射手没血了");
}else {
if(zb.hp<=0) {
System.out.println("对不去僵尸没有血了");
}
else {
System.out.println("射手对僵尸的伤害"+dps);
zb.hp=zb.hp-dps;
if(zb.hp<0) {
zb.hp=0;
System.out.println("僵尸死亡");
return;
}
System.out.println("僵尸还剩："+zb.hp);
}
}
}
}
启动类
public class Test {
public static void main(String []args) {
Zoobie z = new Zoobie();
SunFlower s= new SunFlower();
BeanHunter b= new BeanHunter();
while(true) {
if(z.hp<=0) {
System.out.println("植物胜利");
break;
}
if(s.hp<=0 && b.hp<=0) {
System.out.println("僵尸胜利");
break;
}
double random = Math.random();
if(random<=0.3) {
z.attack(s);
}
else if(random<=0.5) {
z.attack(b);
}
else if(random<=0.8) {
b.attack(z);
}else {
s.addBuff();
}
}
}
}
生成一副扑克
public class Poker2 {
String suit;//花色
String count;//点数
public void giveMe() {
String hs[] ={"红桃","黑桃","方片","梅花"};
String ds[]= {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
Poker2 poke[]=new Poker2[52];
//遍历对象，取到ds【】和hs【】的组合，生成不同组合，存到
int x=0;
for(int i=0;i<hs.length;i++) {
for(int j=0;j<ds.length;j++) {
poke[x]= new Poker2();
poke[x].count=ds[j];
poke[x].suit=hs[i];
x++;
}
}
for(Poker2 s:poke) {
System.out.print(s.suit+s.count+" ");
}
}
public static void main(String []args) {
Poker2 po=new Poker2();
po.giveMe();
}
}
给学员按照成绩排序
学生类及判断成绩的
public class Student {
private String name;
private int id;
private int score;
public Student() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Student[] sort(Student s[]) {
for(int i= 1; i<s.length;i++) {
for(int j=0 ;j<s.length-i;j++) {
if(s[j].score<s[j+1].score) {
Student temp;
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
return s;
}
}
启动器
public class Test {
public static void main(String[] args) {
Student s1 =new Student();
s1.setName("一");
s1.setId(1);
s1.setScore(66);
Student s2 =new Student();
s2.setName("二");
s2.setId(2);
s2.setScore(77);
Student s3 =new Student();
s3.setName("三");
s3.setId(3);
s3.setScore(88);
Student s4 =new Student();
s4.setName("四");
s4.setId(4);
s4.setScore(33);
Student stus[]= {s1,s2,s3,s4};
s1.sort(stus);
// Student[] ss =s1.sort(stus);
for(Student sss:stus) {
System.out.println(sss.getName()+" "+sss.getId()+" "+sss.getScore());
}
}
}
