类和对象的总结
1、对象是具体存在的具体实体，具有明确定义的状态和行为。
类是一个模板，类具有它所有对象相似的特征和行为。
2、程序中的类由两部分组成：属性和方法。属性对应对象的特征，方法对应对象的行为。
3、类的基本格式：
//定义类的格式
public class 类名{
//属性的定义格式
数据类型属性名;
//方法的格式
public 返回值数据类型方法名（数据类型参数名，...）{
//编写代码处
}
}
4、实例化对象和调用方法的格式
实例化对象的关键字是new.
格式：
类名对象名=new 类名();
Teacher t=new Teacher();
调用方法的格式：
对象名.方法名(实参,...);
对象名.属性名=""
t.setname("张三");
t.hour=0;
t.lessons();
5、对象也可以作为参数
eg:
Teacher类：
特征（属性）：姓名，性别，年龄，职称，课程,授课时间……
行为（方法）：授课，改卷，……
public class Teacher{
String name;
int hour;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setHour(int h){
hour=h;
}
public int getHour(){
return hour;
}
public void lessons(Lesson lesson){//Lesson的对象做方法lessons的参数
System.out.print(name+"老师花了"+hour+"小时给学生上"+lesson.getName()+"课。");
}
}
如：张三老师花了2小时给学生授课。张三老师就是一个对象。
对象特征：名字（张三），授课时间（2小时）
对象行为：授课
6、方法分为：构造方法和普通方法
1）构造方法格式：
public 类名（数据类型参数名,...）{
}
eg:
//无参构造方法
public Teacher(){}
//有参构造方法
public Teacher(String name){
this.name=name;
}
2）构造方法用于创建对象。构造方法可以有参数，也可以无参数
3）构造方法和普通方法的区别：
构造方法只和new关键字搭配使用，创建一个对象，而且它只能 在构造函数中被调用，在普通方法中不能调用构造方法；
普通方法不和new搭配使用，对象可以调用普通方法。
7、方法重载
1）对于同名的方法，它的数类型、参数个数、参数顺序至少有一个不同。普通方法和构造方法都可以进行方法重载。
生活中的例子，比如：
李明去吃晚饭，可以先吃饭后吃菜，也可以先吃菜后吃饭，也可以只吃菜。
写字（铅笔，钢笔）{}
写字（铅笔）{}
学习（视频，书）{}
学习（书，视频）{}
2）重载的条件：在方法名相同的前提下，参数类型、参数个数、参数顺序至少有一个不同。
eg:
public Teacher(int hour,String name){
this.hour=hour;
this.name=name;
}
public Teacher(String name){
this.name=name;
}
3）调用重载后的方法：调用方法时，在圆括号中写入的实参与形参 的参数类型、参数个数、参数顺序一一对应
eg:
有两个方法:
public int add(int a,intb){...}
public int add(int a,int b,int c){...}
调用重载后的方法：
c.add(2,3);
c.add(2,3,4);
8、this关键字
1）this关键字表示的是当前调用方法的对象。
2）this关键字有两个用途：
其一：当参数名和属性名相同时，用this可以指向当前调用方法的对象，从而也就区分了参数名和属性名
eg:
public Teacher(String name){
this.name=name;
}
其二：可以通过this关键字调用构造方法
eg:
public Teacher(String name){
this.name=name;
}
public Teacher(){
this("张三");//通过this调用构造方法
}
9、参数传递类型分为：值传递和引用传递
1）原始类型：即8大基本类型 （byte,int,short,long,char,float,double,boolean）,这些类型的数据在调用传递时遵守“值传递”规则。
引用类型：对于引用类型，即类类型（通过类创建的对象的变量名字），这些类型的变量名在调用传递时遵守“引用传递”规则。
2）值传递和引用传递的区别：
值传递：形参类型为原始类型，方法调用时，实参把它的值传递给形参，形参只是用实参的值初始化自己的存储单元内容，实参和形参是两个不同的存储单元，所以方法执行中形参的值的改变不影响实参的值。
引用传递：形参的类型是引用类型，也称传地址。方法调用时，实参是对象（或数组），这是实参和形参指向同一个地址，在方法执行中，对形参的操作实际上就是对实参的操作，这个结果在方法结束后被保留了下来，所以方法执行中形参的改变会影响实参。
值传递的例子：
public class Value {
public static void main(String[] args) {
int i=1;
valueTest(i);
System.out.println("i的值为："+i);
}
public static void valueTest(int i){
i=2;
}
}
结果：i的值为：1
引用传递的例子：
public class Student {
String name;
public Student() {
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Student stu1=new Student();
Student stu2=new Student();
stu1.setName("张三");
stu2.setName("李四");
stu2=stu1;
System.out.println("对象stu1的名字为："+stu1.getName());
System.out.println("对象stu2的名字为："+stu2.getName());
}
}结果为：
对象stu1的名字为：张三
对象stu2的名字为：张三
分析：当执行stu2=stu1时，对象stu1的首地址赋给了stu2，stu1和stu2此时同时指向了“张三”所在内存空间的首地址.
3）String是属于引用传递还是值传递？
String是属于引用传递。Java语言规范规定，String型的变量指向的内存空间是不能被改变的。
eg:
public class StringTest {
public static void main(String[] args) {
String strTest=new String("ab");
setString(strTest);//
System.out.println(strTest);
}
public static void setString(String str){
str=str+"c";
}
}
结果：ab
调用setString()函数时，strTest和str同时指向了”ab”所在的内存单元，然后在setString中试图改变str的值，由于String型的变量指向的内存空间是不能被改变的，所以系统会分配新的内存并令str指向该内存，该内存存储的内容为”abc”，而对于strTest，仍然指向原来的内存单元——“ab”所在的内存单元。这看起来类似值传递，其实，String确实是引用传递。
小飞龙（战士）和大魔王（BOSS）PK，可以使用多种技能，每种技能都有对应的攻击力和得分，直到一方血量为0，游戏结束，最后输出：***胜利！***总分为***。
public class PK {
public static void main(String[] args) {
PK pk=new PK();
Skill [] skill={new Skill(),new Skill("X战火",5,50),new Skill("X战枪",10,100),new Skill("X战剑",8,80)};
Soldier sol=new Soldier("小飞龙",30,skill);
Boss boss=new Boss("大魔王",35,skill);
Random rand=new Random();
int value=rand.nextInt(2);
System.out.println(value);
pk.test(value,sol,boss);
}
public static void test(int v,Soldier sol,Boss boss){
switch(v){
case 0:
while(sol.getBlood()>0&&boss.getBlood()>0){
sol.fight(boss);
if(boss.getBlood()<=0){
System.out.println(sol.getName()+"胜利！"+sol.getName()+"获得总分数为："+sol.getSum()+"。"+boss.getName()+"获得总分数为："+boss.getSum()+"。");
break;
}
boss.fight(sol);
if(sol.getBlood()<=0){
System.out.println(boss.getName()+"胜利！"+boss.getName()+"获得总分数为："+boss.getSum()+"。"+sol.getName()+"获得总分数为："+sol.getSum()+"。");
break;
}
}
break;
case 1:
while(sol.getBlood()>0&&boss.getBlood()>0){
boss.fight(sol);
if(sol.getBlood()<=0){
System.out.println(boss.getName()+"胜利！"+boss.getName()+"获得总分数为："+boss.getSum()+"。"+sol.getName()+"获得总分数为："+sol.getSum()+"。");
break;
}
sol.fight(boss);
if(boss.getBlood()<=0){
System.out.println(sol.getName()+"胜利！"+sol.getName()+"获得总分数为："+sol.getSum()+"。"+boss.getName()+"获得总分数为："+boss.getSum()+"。");
break;
}
}
break;
}
}
}
public class Soldier {
private String name;
private int blood;
private Skill [] array;
private int sum;//战士获得的总分数
public Soldier(String name, int blood, Skill [] array) {
this.name = name;
this.blood = blood;
this.array = array;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
public Skill [] getSkill() {
return array ;
}
public void setSkill(Skill [] skill) {
this.array = skill;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
public void fight(Boss boss){
Random rand=new Random();
Skill skill=array [rand.nextInt(array .length)];
boss.setBlood(boss.getBlood()-skill.getAgressivity());
sum=sum+skill.getScore();
System.out.println(boss.getName()+"剩余血量为："+boss.getBlood()+","+name+"使用技能为:"+skill.getName()+"，"+name+"获得的分数为："+skill.getScore());
}
}
public class Boss {
private String name;
private int blood;
private Skill [] array;
private int sum;
public Boss(String name, int blood, Skill [] array) {
this.name = name;
this.blood = blood;
this.array = array;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
public Skill [] getSkill() {
return array;
}
public void setSkill(Skill [] array) {
this.array = array;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
public void fight(Soldier sol){
Random rand=new Random();
Skill skill=array[rand.nextInt(array.length)];
sol.setBlood(sol.getBlood()-skill.getAgressivity());
sum=sum+skill.getScore();
System.out.println(sol.getName()+"剩余血量为："+sol.getBlood()+","+name+"使用技能为:"+skill.getName()+"，"+name+"获得的分数为："+skill.getScore());
}
}
public class Skill {
private String name;
private int agressivity;//某种技能的攻击力
private int score;//使用某种技能后所得的分数
public Skill(){
this("X战水",3,30);
}
public Skill(String name, int agressivity, int score) {
this.name = name;
this.agressivity = agressivity;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAgressivity() {
return agressivity;
}
public void setAgressivity(int agressivity) {
this.agressivity = agressivity;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
}