How2J——JAVA基础-类和对象

1、
构造方法没有返回类型，类方法有。
2、
类方法 static 所有对象
3、
继承：extends

引用

/*
 *如代码，问题:
h4所指向的对象和h2所指向的对象，是否是同一个对象？
 */
package basis;

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 = h1;//h3指向h1所指的对象
		Hero h4 = h3;
		//h1,h3,h4 3个引用都指向同一个对象。
		
		h1.name = "garen";
		h2.name = "teemo";//对象实例化
		System.out.println(h4.name);
		System.out.println(h2.name);
	}
}

继承

extends
在LOL中，武器是物品的一种，也是有名称和价格的
所以在设计类的时候，可以让武器继承物品，从而继承名称和价格属性

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

实例化出两件护甲
名称 价格 护甲等级
布甲 300 15
锁子甲 500 40
 */
package basis;

//在第一个公共类里面写主类，新的类写下面。方法写里面
public class Hero {
	public static void main(String[]args) {
		Armor cloth = new Armor();//类名
		cloth.name = "布甲";
		cloth.price = 300;
		cloth.ac = 15;
		
		//chain束缚，链条 ，mail邮寄 ，mailed 有甲壳的
		Armor chainMail = new Armor();
		chainMail.name = "锁子甲";
		chainMail.price =500;
		chainMail.ac = 40;
		
		System.out.println(cloth.name + "   " +cloth.price + "   " + cloth.ac);
		System.out.println(chainMail.name + "   " +chainMail.price + "   " + chainMail.ac);
	}
}


//把新写的类放在下面
class Item1{
	String name;
	int price;
}
class Armor extends Item1{
	int ac;
}

方法重载

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

/*
 *设计一个类Support (辅助英雄)继承Hero，提供一个heal(治疗)方法
对Support的heal方法进行重载
heal() 
heal(Hero h) //为指定的英雄加血
heal(Hero h, int hp) //为指定的英雄加了hp的血
 */
//辅助英雄Support继承Hero
class Support extends Hero{
	//方法重载
	public void heal() {
		System.out.println(name + "被一个不知名是好心人救了");
	}
	
	public void heal(Hero h1) {
		System.out.println(name + "为" +h1.name +"加血");
	}
	
	public void heal(Hero h1,int hp) {
		System.out.println(name + "为" +h1.name +"加了" +hp +"的血量");
	}
}

构造方法

通过一个类创建一个对象，这个过程叫做实例化
实例化是通过调用构造方法(又叫做构造器)实现的
构造方法没有返回类型

/*
 *为Hero设计4个参数的构造方法
这四个参数分别是 
String heroName
float heroHP
float heroArmor
int heroMoveSpeed
 */
package basis;

public class heroTest {
	String name;
	float hp;
	float armor;
	int moveSpeed;
	//构造方法
	//和方法差不多，但是无返回值。
	public heroTest(String heroname,float heroHP,float heroArmor,int heroMoveSpeed) {
		name = heroname;
		hp = heroHP;
		armor = heroArmor;
		moveSpeed = heroMoveSpeed;
	}
	public static void main(String[] args) {
		heroTest garen = new heroTest("盖伦",330,30,100);
		System.out.println(garen.name);
	}
}

类属性(static)

1、当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
2、比如盖伦的hp 和 提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的
3、Hero.copyright;

/*
 * 通过garen.copyright修改其值
 garen.copyright = "Blizzard Entertainment Enterprise";
 然后打印teemo.copyright，观察是否有变化
 */
public class heroTest {
	public String name;
	float hp;
	static String copyright;//类属性，静态属性
	
	public static void main(String[]args) {
		heroTest garen = new heroTest();
		//会有警告说，应该是Hero.copyright
		garen.copyright = "人民文学出版社版权所有";
		
		heroTest teemo = new heroTest();
		System.out.println(teemo.copyright);
	}
}

类方法

访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问
Math.random（）；

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

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

package basis;
/*
 * 在一个类方法中，直接调用一个对象方法，
比如在battleWin中调用die()
能否直接调用？ 为什么？
 */

public class Hero {
	public String name;
	//类方法是有返回值的
	public static void battleWin(){
		System.out.println("我赢了！！！");
		//不能直接调用，对象方法要有对象！
		//实例化一个对象，貌似就可以调用了
		Hero garen = new Hero();
		garen.die();
	}
	
	public void die(){
		System.out.println("我死了。");
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Hero.battleWin();
	}
}

属性初始化

先后执行：
声明> 块 > 构造函数

package basis;
/*
 *对象属性的初始化有三种方式
故意把初始化块，放在构造方法下面，问题：

这三种方式，谁先执行？谁后执行？
 */

public class Hero {
	//1、声明该属性时初始化
	public float hp= 110; 
	//2、构造方法中初始化     
	public Hero(){
	    hp = 220;
	}
	//3、块初始化
	{
	    hp = 330;
	}
	public static void main(String[]args){
		Hero garen = new Hero();
		System.out.println(garen.hp);
	}	     
}

访问修饰符

1. 属性通常使用private封装起来（见private专题）
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
   4.简单说, 能用private就用private，不行就放大一级==，用package,再不行就用protected，最后用public。 这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了