It's our wits that make us men.

Java学习笔记(7)类和对象

Posted on By Xc L


什么是Java中的引用?

引用的概念,如果一个变量的类型是 类类型,而非基本类型,那么该变量又叫做引用。

引用和指向

new Hero();

代表创建了一个Hero对象 但是也仅仅是创建了一个对象,没有办法访问它 为了访问这个对象,会使用引用来代表这个对象

Hero h = new Hero();

h这个变量是Hero类型,又叫做引用

=的意思指的是h这个引用代表右侧创建的对象 “代表”在面向对象里,又叫做“指向”

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度
	
	public static void main(String[] args){
		//创建一个对象
		new Hero();

		//使用一个引用来指向这个对象
		Hero h = new Hero();
	}
}

多个引用,一个对象

引用有多个,但是对象只有一个。

在这个例子里,所有引用都指向了同一个对象 对象就像“房产”,引用就像“房产证” 房产证的复印件可以有多张,但是真正的“房产”只有这么一处

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	public static void main(String[] args){
		//使用一个引用来指向这个对象
		Hero h1 = new Hero;
		Hero h2 = h1;//h2指向h1所指向的对象
		Hero h3 = h1;
		Hero h4 = h1;
		Hero h5 = h4;

		//h1,h2,h3,h4,h5 五个引用,都指向同一个对象
	}
}

一个引用,多个对象

第8行,引用garen指向新创建的对象(对象1) 第9行,同一个引用garen指向新创建的对象(对象2) 这个时候,对象1 ,就没有任何引用指向了 换句话说,就没有任何手段控制和访问该对象,那么该对象就变得没有意义。

public class Hero{
	public String name;
	protected float hp;

	public static void main(String[] args){
		Hero garen = new Hero();
		garen = new Hero();
	}
}

练习-引用

如代码,问题 h4所指向的对象和h2所指向的对象,是否是同一个对象?

public class Hero{
	public String name;
	protected float hp;

	public static void main(String[] args){
		Hero h1 = new Hero();
		Hero h2 = new Hero();
		Hero h3;
		Hero h4;
		h3 = h1;
		h4 = h3;
	}
}

什么是Java中的继承

在LOL游戏中,武器是物品的一种,也是有名称和价格的

所以在设计类的时候,可以让武器继承物品,从而继承物品名称和价格属性

物品类 Item

物品类Item,有属性 name, price

public class Item{
	String name;
	int price;
}

武器类 Weapon (不继承)

武器类:Weapon不继承Item的写法

独立设计name和price属性

同时多了一个属性damage攻击力

public class Weapon{
	String name;
	int price;
	int damage;//攻击力
}

武器类Weapon(继承类Item)

这一次Weapon继承Item

虽然自己没有设计name和price ,但是通过继承Item类,也具备了name和price属性

public class Weapon extends Item{
	int damage://攻击力

	public static void main(String[] args){
		Weapon infinityEdge = new Weapon();
		infinityEdge.damage = 65;//damage属性在类weapon中新设计的

		infinityEdge.name = "无尽之刃";//name属性,是从Item中继承来的,就不需要重复设计了
		infinityEdge.price = 3600;
	}
}

练习-护甲

设计一个类Armor护甲 继承Item类,并且额外提供一个属性ac: 护甲等级 int类型

实例化出两件护甲:

名称 价格 护甲等级
布甲 300 15
锁子甲 500 40
public class Armor extends Item{
	int ac ;

	public static void main(String[] args){
		Armor clothArmor = new Armor();
		clothArmor.name = "布甲";
		clothArmor.price = 300;
		clothArmor.ac = 15;

		Armor chainmail = new Aromr();
		chainmail.name = "锁子甲";
		chainmail.price = 500;
		chainmail.ac = 40;
	}
}

什么是Java方法重载

方法重载指的是方法名一样,但是参数类型不一样

attack方法的重载

有一种英雄。叫做物理攻击英雄 ADHero

为ADHero提供三种方法

public void attack()
public void attack(Hero h1)
public void attack(Hero h1,Hero h2)

方法名是一样的,但是参数类型不一样 在调用方法attack的时候,会根据传递的参数类型以及数量,自动调用对应的方法

public class ADHero extends Hero{
	public void attack(){
		System.out.println(name+"进行了一次攻击,但是不确定打中谁了");
	}

	public void attack(Hero h1){
		System.out.println(name+"对"+h1.name+"进行了一次攻击");
	}

	public void attack(Hero h1,Hero h2){
		System.out.println(name+"对"+h1.name+"和"+h2.name+"进行了攻击");
	}

	public static void main(String[] args){
		ADHero bh = new ADHero();
		bh.name = "赏金猎人";

		Hero h1 = new Hero();
		h1.name = "盖伦";
		Hero h2 = new Hero();
		h2.name = "提莫";

		bh.attack(h1);
		bh.attack(h1,h2);
	}
}

可变数量的参数

如果要攻击更多的英雄,就需要设计更多的方法,这样类会显得很累赘,像这样:

public void attack()
public void attack(h1)
public void attack(h1,h2)

这时,可以采用可变数量的参数

只需要设计一个方法 public void attack(Hero... heros) 即可代表上述所有的方法了 在方法里,使用操作数组的方式处理参数heros即可

public class ADHero extends Hero{
	public void attack(){
		System.out.println(name+"进行了一次攻击,但是不确定打中谁了");
	}
	//可变数量的参数
	public void attack(Hero... heros){
		for(int i = 0;i<heros.length;i++){
			System.out.println(name+"攻击了"+heros[i].name);
		}
	}

	public static void main(String[] args){
		ADHero bh = new ADHero();
		bh.name = "赏金猎人";

		Hero h1 = new Hero();
		h1.name = "盖伦";
		Hero h2 = new Hero();
		h2.name = "提莫";

		bh.attack(h1);
		bh.attack(h1,h2);
	}
}

练习-治疗

设计一个类Support(辅助英雄)继承Hero,提供一个heal(治疗)方法 对Support的heal方法进行重载 heal() heal(Hero h)//为指定的英雄加血 heal(Hero h,int hp)//为指定的英雄加了hp 的血

答案:

public class Support extends Hero{
	public void heal(){
		System.out.println(name+"为未指定的英雄加了血");
	}

	public void heal(Hero h){
		System.out.println(name+"为"+h.name+"加了血");
	}
	System void heal(Hero h,int hp){
		System.out.println(name+"为"+h.name+"加了"+hp"血");
	}

	public static void main(String[] args){
		Support soul = new Support();
		soul.name = "魂灵";
		hp = 20;//每次加20血
		Hero h = new Hero();
		h.name = "盖伦";

		soul.heal();
		soul.heal(h);
		soul.heal(h,hp);
	}
}

怎么使用Java构造方法

通过一个类创建一个对象,这个过程叫做实例化

实例化是通过调用构造方法(又叫做**构造器)实现的

什么是构造方法

方法名和类名一样(包括大小写) 没有返回类型 实例化一个对象的时候,必然调用构造方法

public class Hero{
	
	String name;

	float hp;

	float armor;

	int moveSpeed;

	//方法名和类名一样(包括大小写)
	//没有返回类型
	public Hero(){
		System.out.println("实例化一个对象的时候,必然调用构造方法");
	}
	public static void main(String[] args){
		//实例化一个对象的时候,必然调用构造方法
		Hero h = new Hero();
	}
}

隐式的构造方法

Hero类的构造方法是

public Hero(){
}

这个无参的构造方法,如果不写,就会默认提供一个

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//这个无参的构造方法,如果不写,
	//就会默认提供一个无参的构造方法
	// public Hero(){
	//		System.out.println("调用Hero的构造方法");
	// }

	public static void main(String[] args){
		Hero garen = new Hero();
		garen.name = "盖伦";
		garen.hp = 616.28f;
		garen.armor = 27.536f;
		garen.moveSpeed = 350;

		Hero teemo = new Hero();
		teemo.name = "提莫";
		teemo.hp = 383f;
		teemo.armor = 14f;
		teemo.moveSpeed = 330;
	}
}

如果提供了一个有参的构造方法

一旦提供了一个有参的构造方法 同时又没有显式的提供一个无参的构造方法 那么默认的无参的构造方法,就没有了

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//有参的构造方法
	//默认的无参的构造方法就失效了
	public Hero(String heroname){
		name = heroname;
	}

	public static void main(String[] args){
		Hero garen = new Hero("盖伦");

		Hero garen = new Hero();//默认的无参构造方法就没有了
	}
}

构造方法的重载

和普通方法一样,构造方法也可以重载

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//带一个参数的构造方法
	public Hero(String heroname){
		name = heroname;
	}

	//带两个参数的构造方法
	public Hero(String name,float herohp){
		name = heroname;
		hp = herohp;
	}

	public static void main(String[] args){
		Hero garen = new Hero("盖伦");
		Hero teemo = new Hero("提莫",383);
	}
}

练习-构造方法

为Hero设计4参数的构造方法 这四个参数分别是 String heroName float heroHp float heroArmor int heroMoveSpeed

答案:

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;
    }
}

Java中的this是什么意思?

this这个关键字,相当于普通话里的“我”

小明说“我吃了”这个时候,“我” 代表小明 小红说“我吃了”这个时候,“我” 代表小红 “我”代表当前人物

this这个关键字,相当于普通话的“我” this即代表当前对象

this代表当前对象

this代表当前对象

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//打印内存中的虚拟地址
	public void showAddressInMemory(){
		System.out.println("打印this看到的虚拟地址:"+this);
	}

	public static void main(String[] args){
		Hero garen = new Hero();
		garen.name = "盖伦";
		//直接打印对象,会显示该对象在内存中的虚拟地址
		//格式:Hero@c17164  c17164即虚拟地址,每次执行,得到的地址不一定一样

		System.out.println("打印对象看到的虚拟地址:"+garen);
		//调用showAddressInMemory,打印该对象的this,显示相同的虚拟地址
		garen.showAddressInMemory();

		Hero teemo = new Hero();
		teemo.name = "提莫";
		System.out.println("打印对象看到的虚拟地址:"+teemo);
		teemo.showAddressInMemory();
	}
}

通过this访问属性

通过this关键字访问对象的属性

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//参数名和属性名一样
	//在方法体中,只能访问到参数name
	public void setName1(String name){
		name = name;
	}

	//为了避免setName1中的问题,参数名不得不使用其他变量名
	public void setName2(String heroName){
		name = heroName;
	}

	//通过this访问属性
	public void setName3(String name){
		//name 代表的是参数name
		//this.name 代表的是属性name
		this.name = name;
	}

	public static void main(String[] args){
		Hero h = new Hero();

		h.setName1("teemo");
		System.out.println(h.name);

		h.setName2("garen");
		System.out.println(h.name);

		h.setName3("死歌");
		System.out.println(h.name);
	}
}

通过this调用其他的构造方法

如果要在一个构造方法中,调用另一个构造方法,可以使用 this()

public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//带一个参数的构造方法
	public Hero(String name){
		System.out.println("一个参数的构造方法");
		this.name = name;
	}

	//带两个参数的构造方法
	public Hero(String name,float hp){
		this(name);//等同于this.name = name;
		System.out.println("两个参数的构造方法");
		this.hp = hp;
	}

	public static void main(String[] args){
		Hero teemo = new Hero("提莫",383);

		System.out.println(teemo.name);
	}
}

练习-构造方法

设计一个构造方法,但是参数名称不太一样,分别是 String name float hp float armor int moveSpeed 不仅如此,在这个构造方法中,调用这个构造方法

public Hero(String name,float hp)

答案:

public class Hero{
	String name;

	float hp;

	float armor;

	int moveSpeed;

	//带一个参数的构造方法
	public Hero(String name){
		System.out.println("一个参数的构造方法");
		this.name = name;
	}

	//带两个参数的构造方法
	public Hero(String name,float hp){
		this.name;
		System.out.println("两个参数的构造方法");
		this.hp = hp;
	}

	//带四个参数的构造方法
	public Hero(String name,float hp,float armor,int moveSpeed){
		this(name,hp);
		this.armor = armor;
		this.moveSpeed = moveSpeed;
	}

	public static void main(String[] args){
		Hero teemo = new Hero("提莫",383);
		System.out.println(teemo.name);
		Hero db = new Hero("死歌",400,27,360);
		System.out.println(db.moveSpeed);
	}
}

Java中的传参详解

变量有两种 “基本类型” 和 “类类型”

参数也是变量,所以传参分为: 基本类型传参 类类型传参

基本类型传参

基本类型传参 在方法内,无法修改方法外的基本类型参数

public class Hero{
	String name;//姓名

	float hp; //血量

	float armor;//护甲

	int moveSpeed;//移动速度

	public void huixue(int xp){
		hp = hp + xp;
		//回血完毕后,血瓶 = 0
		xp = 0;
	}

	public Hero(String name,float hp){
		this.name = name;
		this.hp = hp;
	}

	public static void main(String[] args){
		Hero teemo = new Hero("提莫",383);
		//血瓶,其值是100
		int xueping  = 100;

		//提莫通过这个血瓶回血
		teemo.huixue(xueping);

		System.out.println(xueping);
	}
}

此时上面的程序输出仍未 100

引用 与 =

如果一个变量是基本类型 比如 int hp = 50 我们就直接管hp叫变量 =表示复制的意思 如果一个变量是类类型 比如 Hero h = new Hero(); 我们就管 h 叫做引用。 = 不再是赋值的意思 = 表示指向的意思 比如 Hero h = new Hero(); 这句话的意思是 引用 h,指向一个Hero对象

类类型传参

类类型又叫引用 第24行的引用teemo与底17行的hero,是不同的引用 通过调用garen.attack(teemo,100);使得这两个引用都指向了同一个对象 所以在第18行hero.hp = hero.hp - damage;就使得该对象的hp值,发生了变化 因此第25行,打印该对象的hp值就是变化后的值

public class Hero{

	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	public Hero(String name,float hp){
		this.name = name;
		this.hp = hp;
	}

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

	public static void main(String[] args){
		Hero teemo = new Hero("提莫",383);
		Hero garen = new Hero("盖伦",616);
		garen.attack(teemo,100);
		System.out.println(teemo.hp);
	}
}

运行上面的程序,结果输出 :283(因为383-100)

练习-传参

在方法中,使参数引用指向一个新的对象,外面的引用是指向原来的对象?还是新的对象?

public class Hero{

	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	public Hero(){

	}

	public Hero(String name,float hp){
		this.name = name;
		this.hp = hp;
	}

	//复活
	public void revive(Hero h){
		h = new Hero("提莫",383);
		//只是h的作用域在这里
		System.out.println("复活",h.hp);
	}

	public static void main(String[] args){
		Hero teemo = new Hero("提莫",383);
		System.out.println(teemo.hp);
		//受到400伤害,挂了
		teemo.hp = teemo.hp - 400;
		System.out.println(teemo.hp);
		//只是调用了方法,但是teemo的hp还没有赋值,所以还是原来的-17
		teemo.revive(teemo);
		System.out.println(teemo.hp);
		//问题:System.out.println(teemo.hp);输出多少?怎么理解
	}
}

答案:teemo.hp=-17,不变。传递的是对象变量teemo的值,即对象实际存在堆内存中的地址。方法体开始执行前形参h和teemo都是对同一个堆内存空间的对象(main方法中的new Hero(“提莫”,383)对象)的引用。而在方法体中我们将h改为了对另一个堆内存空间的对象(复活方法中的new Hero(“提莫”,383)对象)的引用,而teemo对象变量没有任何改动。


Java中的包package

包:package

把比较接近的类,规划在同一个包下

把比较相近的类,规划在同一个包下

Hero,ADHero规划在一个包,叫做character(角色)

Item,Weapon规划在另一个包下,叫做property

在最开始的地方声明该类所处于的包名

package character;
public class Hero{
	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度
}

使用其他包下的类,必须import

使用同一个包下的其他类,直接使用即可 但是要使用其他包下的类,必须import

package character;

//Weapon类在其他包里,使用必须进行import
import property.Weapon;

public class Hero{

	String name;//姓名

	float hp;//血量

	float armor;//护甲

	int moveSpeed;//移动速度

	//装备一把武器
	public void equip(Weapon w){
	}
}

练习-包

创建一个新的包character1,并且让治疗类Support 声明在这个包下

答案:

package character1;
import character.Hero;//必须导入character包下的Hero类

public class Support extends Hero{
	public void heal(){
		System.out.println("对未指定的英雄进行了治疗");
	}

	public void heal(Hero hero){
		System.out.println("对"+hero+"加血");
	}

	public void heal(Hero hero,int hp){
		System.out.println("对"+hero+"加了"+hp+"血");
	}
}

Java的四种访问修饰符

成员变量有四种修饰符 private私有的 package/friendly/default不写 protected受保护的 public公共的

比如public表示公共的

public String name;

而maxHP没有修饰符 即代表 package/friendly/default

float maxHP;

类之间的关系

类和类之间的关系有如下几种: 以Hero为例 自身:指的是Hero自己 同包子类:ADHero这个类是Hero的子类,并且和Hero处于同一个包下 不同包子类:Support这个类是Hero的子类,但是在另一个包下 同包类: GiantDragon这个类和Hero是同一个包,但是彼此没有继承关系 其他类:Item这个类,在不同包,也没有继承关系的类

private私有的

使用private修饰属性 自身:是可以访问的 同包子类:不能继承 不同包子类:不能继承 同包类:不能访问 其他包类:不能访问 注:红色字体,表示不可行

package character;

import property.Weapon;

public class Hero{
	//属性id是private的,只有Hero自己可以访问
	//子类不能继承
	//其他类也不能访问
	private int id;

	String name;

	float armor;

	int moveSpeed;

	public void equip(Weapon w){
		
	}
}

package/friendly/default 不写

没有修饰符即代表packa/friendly/default

float maxHP; 血量上限

package character;

import property.Weapon;

public class Hero{
	private int id;

	String name;

	//protected修饰符的属性 hp
	//自己可以访问

	//同包子类可以继承
	//不同包子类可以继承

	//同包类可以访问
	//不同包类不能访问
	protected float hp;

	float armor;

	int moveSpeed;

	public void equip(Weapon w){

	}
}

public公共的

公共的修饰符 public String name;姓名 任何地方,都可以访问

package character;

import property.Weapon;

public class Hero{
	private int id;

	//public的属性 name
	//自己可以访问

	//同包子类可以继承
	//不同的子类也可以继承

	//同包类可以访问
	//不同包类也可以访问

	public String name;

	protected float hp;

	float armor;

	int moveSpeed;

	public void equip(Weapon w){
		
	}
}

总结

那么什么情况该用什么修饰符呢?

那么什么情况该用什么修饰符呢?

从作用域来看,public 能够使用所有的情况。但是大家在工作的时候,又不会真的全部都使用public,那么到底什么情况该用什么修饰符呢?

  1. 属性通常使用private封装起来
  2. 方法一般使用public用于调用
  3. 会被子类继承的方法,通常使用protected
  4. package用的不多,一般新手会用package,因为还不知道有修饰符这个东西

再就是作用范围最小范围 简单说,能用private就用private,不行就放大一级,用户package,再不行就用protected,最后用public。这样就能把数据尽量的封装起来,没有必要露出来,就不用露出来了


类属性

当一个属性被static修饰的时候,就叫做类属性,又叫做静态属性

当一个属性被声明成类属性,那么所有的对象,都共享一个值

与对象属性对比:

不同对象的 对象属性 的值都可能不一样
比如盖伦的hp 和 提莫的hp 是不一样的
但是所有对象的 类属性 的值,都是一样的

类属性

类属性:又叫做静态属性

对象属性:又叫做实例属性,非静态属性

如果一个属性声明成类属性,那么所有的对象,都共享这么一个值

给英雄设置一个类属性,叫做“版权”(copyright),无论有多少个具体的英雄,所有的英雄的版权都属于Riot Games公司

package character;

public class Hero{
	public String name;//实例属性,对象属性,非静态属性
	protected float hp;
	static String copyright;//类属性,静态属性

	public static void main(String[] args){
		Hero garen = new Hero();
		garen.name = "盖伦";

		Hero.copyright = "版权由Riot Games公司所有";

		System.out.println(garen.name);
		System.out.println(garen.copyright);

		Hero teemo = new Hero();
		teemo.name = "提莫";
		System.out.println(teemo.name);
		System.out.println(teemo.copyright);
	}
}

访问类属性

访问类属性有两种方式

  1. 对象.类属性
    teemo.copyright;
    
  2. 类.类属性
    Hero.copyright;
    

这两种方式都可以访问类属性,访问即修改和获取,但hi建议使用第二种类.类属性的方式进行,这样更符合语义上的理解

什么时候使用对象属性,什么时候使用类属性

如果一个属性,每个英雄都不一样,比如name,这样的属性就应该设计为对象属性,因为它是跟着对象走的,每个对象的name都是不同的

如果一个属性,所有的英雄都共享,都是一样的,那么就应该设计为类属性。比如血量上限,所有的英雄的血量上限都是9999,不会因为英雄不同,而取不同的值。这样的属性,就适合设计为类属性

练习-类属性

通过garen.copyright修改其值

garen.copyright = "Blizzard Entertainment Enterprise";

然后打印teemo.copyright,观察是否有变化

答案:

package character;

public class Hero{
	public String name;//实例属性,对象属性,非静态属性

	protected float hp;

	static String copyright;

	public static void main(String[] args){
		Hero garen = new Hero();
		garen.name = "盖伦";

		Hero.copyright = "版权由Riot Games公司所有";
		garen.copyright = "Blizzard Entertainment Enterprise";
		System.out.println(garen.name);
		System.out.println(garen.copyright);

		Hero teemo = new Hero();
		teemo.name = "提莫";
		System.out.println(teemo.name);
		System.out.println(teemo.copyright);
	}
}

将会打印输出: 盖伦 Blizzard Entertainment Enterprise 提莫 Blizzard Entertainment Enterprise (修改对象.类属性并不能修改类属性)


类方法

类方法:又叫静态方法

对象方法:又叫实例方法,非静态方法

访问一个对象方法,必须建立在有一个对象的前提的基础上

访问类方法,不需要对象的存在,直接就访问

类方法

类方法:又叫静态方法

对象方法:又叫实例方法,非静态方法

访问一个对象方法,必须建立在有一个对象的前提的基础上

访问类方法,不需要对象的存在,直接就访问

package character;

public class Hero{
	public String name;
	protected float hp;

	//实例方法,对象方法。非静态方法
	//必须有对象才能够调用

	public void die(){
		hp = 0;
	}

	//类方法,静态方法
	//通过类就可以直接调用
	public static void battleWin(){
		System.out.println("battle win");
	}

	public static void main(String[] args){
		Hero garen = new Hero();
		garen.name = "盖伦";
		//必须有一个对象才能调用
		garen.die();

		Hero teemo = new Hero();
		garen.name = "提莫";

		//无需对象,直接通过类调用
		Hero.battleWin();
	}
}

调用类方法

和访问类属性一样,调用类方法也有两种方式

  1. 对象.类方法
    garen.battleWin();
    
  2. 类.类方法
    Hero.battleWin();
    

这两种方式都可以调用类方法,但是建议使用第二种 类.类方法 的方式进行,这样更符合语义上的理解。 并且在很多时候,并没有实例,比如在前面练习的时候用到的随机数的获取办法

Math.random()

romdom()就是一个类方法,直接通过类Math进行调用,并没有一个Math的实例存在。

什么时候设计对象方法,什么时候设计类方法

如果在某一个方法里,调用了对象属性,比如

public String getName(){
	return name;
}

name属性是对象属性,只有存在一个具体对象的时候,name才有意义。如果方法里访问了对象属性,那么这个方法,就必须设计为对象方法。

如果一个方法,没有调用任何对象属性,那么就可以考虑设计为类方法。比如

public static void printGameDuration(){
	System.out.println("已经玩了10分50秒");
}

printGameDuration打印当前玩了多长时间了,不和某一个具体的英雄关联起来,所有的英雄都是一样的。这样的方法,更带有功能性色彩 就像取随机数一样,random()是一个功能用途的方法

Math.random()

练习-类方法

在一个类方法中,直接调用一个对象方法, 比如子啊battleWin中嗲用die() 能否直接调用?为什么?

答案:不能调用。静态方法只能访问静态变量,调用静态方法,不能调用实例方法。 因为实例方法是对象相关联的,而静态方法没有对象也可以调用,所以执行静态方法时,可能没有实例对象,这时候如果调用静态方法就找不到和方法绑定的对象。


属性初始化

对象属性初始化

对象属性初始化有3种

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

public class Hero{
	public String name = "some hero";//声明该属性的时候初始化
	protected float hp;
	float maxHP;

	{
		maxHP = 200;//初始化块
	}

	public Hero(){
		hp = 100;//构造方法中初始化
	}
}

类属性初始化

类属性初始化有2种

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

public class Hero{
	public String name = "some hero";//声明该属性的时候初始化
	protected float hp;
	float maxHP;
	{
		maxHP = 200;//初始化块
	}
	public Hero(){
		hp = 100;//构造方法中初始化
		
	}
}

类属性初始化

类属性初始化有2种

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

public class Hero{
	public String name;
	protected float hp;
	float maxHP;

	//物品栏的容量
	public static int itemCapacity = 8;//声明的时候初始化

	static {
		itemCapacity = 6;//静态初始化块中初始化
	}
}

练习-属性初始化‘

对象属性的初始化有三种方式 故意把初始化块,放在构造方法下面,问题:

这三种方式,谁先执行?谁后执行?

package character;

public class Hero{
	public String name = "some hero";

	public Hero(){
		name = "one hero";
	}
	{
		name = "the name";
	}
}

答案:声明>初始化块>构造方法。声明该属性的时候初始化最快,其次是初始化块,最后是构造方法初始化。


单例模式

LOL里有一个怪脚大龙 GiantDragon,只有一只,所以该类,只能被实例化一次

单例模式

单例模式又叫做Singleton模式,指的是一个类,在一个JVM里,只有一个实例存在。

饿汉式单例模式

GiantDragon应该只有一只,通过私有化其构造方法,使得外部无法通过new得到新的实例。

GiantDragon提供了一个public static的getInstance的方法,外部调用者通过使用该方法获取12行定义的对象,而且每一次都是获取同一个对象。从而达到单例的目的。 这种单例模式又叫做饿汉式单例模式,无论如何都会创建一个实例。

//GiantDragon.java
package character;

public class GiantDragon{
	//私有化构造方法使得该类无法在外部通过new进行实例化
	private GiantDragon(){
	}

	//准备一个类属性,指向一个实例化对象。因为是类属性,所以只有一个

	private static GiantDragon instance = new GiantDragon();

	//public static 方法,提供给调用者获取12行定义的对象
	public static GiantDragon getInstance(){
		return instance;
	}
}
//TestGiantDragon.java
package character;

public class TestGiantDragon{
	public static void main(String[] args){
		//通过new 实例化会报错
		//GiantDragon g = new GiantDragon();
		//只能通过getInstance得到对象

		GiantDragon g1 = GiantDragon.getInstance();
		GiantDragon g2 = GiantDragon.getInstance();
		GiantDragon g3 = GiantDragon.getInstance();

		//都是同一个对象
		System.out.println(g1==g2);
		System.out.println(g1==g3);
	}
}

懒汉式单例模式

懒汉式单例模式与饿汉式单例模式不同,只有在调用getInstance的时候,才会创建实例

//GiantDragon.java
package character;

public class GiantDragon{
	//私有化构造方法使得该类无法在外部通过new进行实例化
	private GiantDragon(){
	}

	//准备一个类属性,用于指向一个实例化对象,但暂时指向null(即不赋值)
	public static GiantDragon getInstance(){
		//第一次访问的时候,发现instance没有指向任何对象,这时实例化一个对象
		if(null==instance){
			instance = new GiantDragon();
		}
		//返回instance指向的对象
		return instance;
	}
}
//TestGiantDragon.java
package character;

public class TestGiantDragon{
	public static void main(String[] args){
		//通过new实例化会报错
		//GiantDragon g = new GiantDragon();
		//只能通过getInstance得到对象

		GiantDragon g1 = GiantDragon.getInstance();
		GiantDragon g2 = GiantDragon.getInstance();
		GiantDragon g3 = GiantDragon.getInstance();

		//都是同一个对象
		System.out.println(g1==g2);
		System.out,println(g1==g3);
	}
}

什么时候使用饿汉式,什么时候使用懒汉式

饿汉式是立即加载的方法,无论是否会用到这个对象,都会加载 如果在构造方法里写了性能消耗较大,占时较久的代码,比如建立与数据库的连接,那么就会在启动的时候感觉稍微有些卡顿。

懒汉式,是延迟加载的方法,只有使用的时候才会加载。并且有线程安全的考量(这里暂不对线程展开) 使用懒汉模式,在启动的时候,会感觉到比饿汉式略快,因为并没有做对象实例化。但是在第一次调用的时候,会进行实例化操作,感觉上就略慢。

(简单来说就是类属性何时初始化有区别)

单例模式三元素

这个是面试时候经常会考的点,面试题通常的问法是:

什么是单例模式

回答的时候,要答到三元素

  1. 构造方法私有化
  2. 静态属性指向实例
  3. public static的getInstance方法,返回第二步的静态属性

练习-单例模式

使用饿汉式单例模式,把Hero类改造成单例模式 使用懒汉式单例模式,把Item类改造成单例模式 答案:

//使用饿汉式单例模式改造

package character;

public class Hero1{
	public String name = "some hero";
	//私有化静态方法
	private Hero1(){	
	}

	//准备一个类属性,指向一个实例化对象
	private static Hero1 hero_instance=new Hero1();
	public static Hero1 getInstance(){
		return hero_instance;
	}
}
//Item懒汉单例模式
package character;

public class Item{
	private Item(){
	}

	private static Item instance;
	public static Item getInstance(){
		if(null==instance){
			instance = new Item();
		}
		
		return instance;
	}
}

枚举类型

预先定义的常量

枚举enum是一种特殊的类(还是类),使用枚举可以很方便的定义常量 比如设计一个枚举类型 季节,里面有4种常量

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

一个常用的场合就是switch语句中,使用枚举来进行判断

注: 因为是常量,所以一般都是全大写

//HelloWorld.java
public class HelloWorld{
	public static void main(String[] args){
		Season season = Season.SPRING;
		switch(season){
		case SPRING:
			System.out.println("春天");
			break;
		case SUMMER:
			System.out.println("夏天");
			break;
		case AUTUMN:
			System.out.println("秋天");
			break;
		case WINTER:
			System.out.println("冬天");
			break;
		}
	}
}
//Season.java
public enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}

使用枚举的好处

假设在使用switch的时候,不是枚举,而是使用int,而int的取值范围就不只是1-4,有可能取一个超出1-4之间的值,这样判断结果就似是而非了。(因为只有4个季节)

但是使用枚举,就能把范围死死的限定在这四个当中

SPRING,SUMMER,AUTUMN,WINTER

而不会出现奇怪的第5季节

public class HelloWorld{
	public static void main(String[] args){
		int season = 5;
		switch (season) {
        case 1:
            System.out.println("春天");
            break;
        case 2:
            System.out.println("夏天");
            break;
        case 3:
            System.out.println("秋天");
            break;
        case 4:
            System.out.println("冬天");
            break;
        }
	}
}

遍历枚举

借助增强型for循环,可以很方便的遍历一个枚举部有哪里常量

public class HelloWorld{
	public static void main(String[] args){
		for(Season s : Season.values()){
			System.out.println(s);
		}
	}
}

练习-枚举

英雄联盟中有这么一些分类 TANK (坦克) WIZARD (法师 ) ASSASSIN (刺客) ASSIST (辅助) WARRIOR (近战) RANGED (远程 ) PUSH (推进) FARMING (打野) 设计一个枚举类型HeroType,使用上述分类作为常量

再编写一段switch语句,把每种枚举常量输出为中文字符串

答案:

//HeroType.java
package HeroTest;
//枚举类
public enum HeroType{
	TANK, WIZARD, ASSASSIN, ASSIST, WARRIOR, RANGE
}

//遍历枚举类并输出中文
package HeroTest;

public class Hero{
	public static void main(String[] args){
		for(HeroType a : HeroType.values()){
		switch(a){
			case TANK:
                System.out.println("坦克");
                break;
            case WIZARD:
                System.out.println("法师");
                break;
            case ASSASSIN:
                System.out.println("刺客");
                break;
            case ASSIST:
                System.out.println("辅助");
                break;
            case WARRIOR:
                System.out.println("近战");
                break;
            case RANGED:
                System.out.println("远程");
                break;
            case PUSH:
                System.out.println("推进");
                break;
            case FARMING:
                System.out.println("打野");
                break;
		}	
		}
	}
}