构造器
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 for(int j=0;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 for(int j=0 ;j if(s[j].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()); } } }给学员按照成绩排序
学生类及判断成绩的
JavaBean