JAVA学习第四天：类和对象

1. 类的引用和继承

列如现在有物品Item类

public class Item {
	String name;
	int price;
}

使护甲Armor类，继承Item的属性

public class Armor extends Item {
	//可以添加额外属性ac,且不用重复设计父类的属性
	int ac;
	
	public static void main(String[] arg){
		//引用bujia指向对象Armor
		Armor bujia = new Armor();
		bujia.name = "布甲";
		bujia.price = 300;
		bujia.ac = 15;
		
		Armor suozijia = new Armor();
		suozijia.name = "锁子甲";
		suozijia.price = 500;
		suozijia.ac = 40;
	}
}

2. 重载

即对同一方法名，设置不同的参数，如下

public class Support extends Hero {
	//为Support添加heal方法
	public void heal(){
		System.out.println(name + "进行了一次治疗");
	}
	public void heal(Hero...heros){
		for(int i = 0;i < heros.length;i++){
			System.out.println(name + "治疗了" + heros[i].name);
			heros[i].hp = heros[i].hp + 100;
		}
	}
	
	public void heal(Hero hero, int hp){
		System.out.println(name + "治疗了" + hero.name + hp + "点血");
	}
	
	public static void main(String[] args){
		Support qinnv = new Support();
		qinnv.name = "琴女";
		
		Hero garen = new Hero();
		garen.name = "盖伦";
		garen.hp = 616.28f;
		garen.armor = 616.28f;
		garen.moveSpeed = 350;
		
		Hero teemo = new Hero();
		teemo.name = "提莫";
		teemo.hp = 383.f;
		teemo.armor = 14f;
		teemo.moveSpeed = 330;
		
		qinnv.heal();
		qinnv.heal(garen);
		qinnv.heal(garen, 100);
		qinnv.heal(garen,teemo);
		
	}

}

输出为

琴女进行了一次治疗
琴女治疗了盖伦
琴女治疗了盖伦100点血
琴女治疗了盖伦
琴女治疗了提莫

3. 构造方法

实例化即通过一个类创建一个对象，而实例化是通过调用构造方法（构造器）实现的。
构造方法名和类名一样，且没有返回类型。
如果没有写构造方法，则系统会默认提供一个无参数的构造方法；如果写了带参数的构造方法，则不再提供默认的无参构造方法。代码如下；给Hero类添加带参数的构造方法并实例化。

public class Hero {
	String name;
	float hp;
	float armor;
	int moveSpeed;
	
	public Hero(String heroName,float heroHp,float heroArmor,int heroMoveSpeed){
		name = heroName;
		hp = heroHp;
		armor = heroArmor;
		moveSpeed = heroMoveSpeed;
	}
	public Hero(){} //有无参数的实例化，所以添加这个构造方法
	
	public static void  main(String[] arg){
		Hero garen = new Hero("盖伦",450,45,360);
		System.out.println("新英雄：" + garen.name);
	}
}

4. this

this相当于我，代表当前对象，可以用来访问对象属性、调用其他构造方法等；
练习要求，使用this完成Hero类的构造方法，并使用this调用Hero类的不同参数的构造方法；代码如下：

//构造方法（含两个参数，可在下方通过this调用）
	public Hero(String name,float hp){
		this.name = name;
		this.hp = hp;
	}
	
	public Hero(String name,float hp,float armor,int moveSpeed){
		this(name,hp); //通过this调用构造方法
		this.armor = armor;
		this.moveSpeed = moveSpeed;
	}
	
	public Hero(){}
	
	public static void  main(String[] arg){
		Hero temmo = new Hero("提莫",250);
		Hero garen = new Hero("盖伦",450,45,360);
		System.out.println("新英雄：" + garen.name + "和" + temmo.name);
	}

输出：

新英雄：盖伦和提莫

5. 传参

传参分为基本类型传参和类类型传参

//moveSpeed为基本类型变量，该 “=” 表示赋值
int moveSpeed = 350; 
//Hero为类类型，该“=”表示指向，引用temmo指向Hero
Hero temmo = new Hero();

类类型传参

// 攻击一个英雄，并让他掉damage点血
    public void attack(Hero hero, int damage) {
        hero.hp = hero.hp - damage;
    }

提出问题：

    //构造方法
    public Hero(String name,float hp){
        this.name = name;
        this.hp = hp;
    } 
    //复活方法
    public void revive(Hero h){
        h = new Hero("提莫",383);
    } 
    
    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);         
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
        //调用复活方法
        teemo.revive(teemo);         
        //hp输出多少？
        System.out.println(teemo.hp);         
    }

返回值应该为：-17.0
复活的为"新"的temmo,也就是对象h,而h的属性h.name = temmo。所以temmo对象的temmo.hp = -17.0; h.hp = 383.

6. 包 package

package用来规划存放相似的类，便于管理。
同一个包下，使用其他的类可以直接使用，但使用其他包下的类需要使用 import 导入。

7. 访问修饰符

修饰符	含义
private	私有的
protected	受保护的
public	公共的
无	package/friendly/default

类之间的关系

	自身	同包子类	不同包子类	同包类	其他类
private	访问	不能继承	不能继承	不能访问	不能访问
protected	访问	可以继承	可以继承	可以访问	不能访问
public	访问	可以继承	可以继承	可以访问	可以访问
无修饰	访问	可以继承	不能继承	可以访问	不能访问

如下：

package charactor; 
import property.Weapon; 
public class Hero {
    private int id; //私有属性
    public String name; //公有属性
    protected float hp;//保护型属性
    float armor;//无修饰符属性
    int moveSpeed;
    public void equip(Weapon w) {
    }
}

作用范围最小原则，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。

8. 类属性

类属性：静态属性;所有对象都共享的属性，如血量上限。
对象属性：非静态属性，对象属性实；跟着对象走，不同对象属性不同时。
如：

static String copyright;//静态属性
private int moveSpeed;//非静态属性,对象属性

访问类属性方式

提出问题：

Hero.copyright;
temmo.copyright;
garen.copyright = "Blizzard Entertainment Enterprise";
//此时输出temmod额copyright，会不会变化？

答：会变化，变成风暴英雄（手动滑稽）；
类属性只有一个，修改后也共享。

9. 类方法

同类属性；
类方法：静态方法；
对象方法：非静态方法、实例方法。
访问一个对象方法，必须建立在有一个对象的前提的基础上，但访问类方法，不需要对象的存在，直接就访问。
调用、使用同类属性。

10. 属性初始化

对象属性初始化：

1. 声明该属性的时候初始化
2. 构造方法中初始化
3. 初始化块

类属性初始化：

1. 声明该属性的时候初始化
2. 静态初始化块

对象初始化的执行顺序：

public class Hero {
    public String name =Hero.getName("属性声明") ;
      
    public Hero(){
        name = Hero.getName("构造方法");
    }
    {
        name = Hero.getName("初始化块");
    }     
    public static String getName(String pos){
        String result= "name "+pos;
        System.out.println(result);
        return result;
    }     
    public static void main(String[] args) {
        new Hero();
    }     
}

结果：

name 属性声明
name 初始化块
name 构造方法

11. 单例模式

在一个类里，只有一个实例存在

饿汉式单例模式

public class GiantDragon {
 //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){    
    } 
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个 
    private static GiantDragon instance = new GiantDragon();     
    //public static 方法，提供给调用者获取定义的对象
    public static GiantDragon getInstance(){
        return instance;
    }
}

懒汉式单例模式

public class GiantDragon {  
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       
    }  
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;     
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }      
}

12.枚举类型

枚举enum是一种特殊的类，使用枚举可以很方便的定义常量。比如设计一个枚举类型 季节。方便在switch中使用。

public enum Season {
	SPRING,SUMMER,AUTUMN,WINTER
}

依旧吹大海同学的彩虹屁（手动滑稽）