JAVA基础之类和对象

最新推荐文章于 2023-11-09 17:12:01 发布

凌晨两点半还不回家

最新推荐文章于 2023-11-09 17:12:01 发布

阅读量397

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/qq_35654080/article/details/101597358

版权

JAVA 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

引用

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

引用和指向

new Hero();

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

Hero h = new Hero();

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

引用和指向

package leiAndduixiang;

public class Yinyong
{

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		
		//创建一个对象
		new Yinyong();
		
		//使用一个引用来指向这个对象
		Yinyong y = new Yinyong();

	}

}

多个引用，一个对象

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

多个引用，一个对象

package leiAndduixiang;

public class Yinyong
{

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		
		//创建一个对象
		new Yinyong();
		
		//使用一个引用来指向这个对象
		Yinyong y = new Yinyong();
		Yinyong y1 = y;//y1指向y所指向的对象
		Yinyong y2 = y;
		Yinyong y3 = y2;
		
		//y,y1,y2,y3四个引用都指向一个对象

	}

}

一个引用，多个对象

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

一个引用，多个对象

package charactor;
 
public class Hero {
    public String name;
    protected float hp;
 
    public static void main(String[] args) {
           Hero garen =  new Hero();
           garen =  new Hero();
    }
}

练习-引用

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

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

h4指向h1所指向的对象，与h2指向不同。

继承

父类

package leiAndduixiang;

public class Jicheng {
	//有属性name,price
	String name;
	int price;

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

子类

package leiAndduixiang;

public class Weapon extends Jicheng 
{
	//从Jicheng类中继承了name,price属性
	int damage;//攻击力

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Weapon w = new Weapon();
		w.damage = 65;
		w.name = "无尽之刃";//从Jicheng类中继承了name属性
		w.price = 3600;//从Jicheng类中继承了price属性

	}

}

练习-护甲

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

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

package leiAndduixiang;

public class Armor extends Jicheng 
{
	int ac;

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Armor bujia = new Armor();
		bujia.price = 300;
		bujia.ac = 15;
		
		Armor suozijia = new Armor();
		suozijia.price = 500;
		suozijia.ac = 40;

	}

}

方法重载

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

attack方法的重载

有一种英雄，叫做物理攻击英雄 ADHero
为ADHero 提供三种方法

public void attack()

public void attack(Jicheng h1)

public void attack(Jichengh1, Jichengh2)

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

package leiAndduixiang;

public class ADHero extends Jicheng
{
	public void attack()
	{
		System.out.println(name+"进行了一次攻击，但是不知道目标");
		
	}
	public void attack(Jicheng h1)
	{
		System.out.println(name+"对"+h1.name+"进行了一次攻击");
	}
	public void attack(Jicheng h1,Jicheng h2)
	{
		System.out.println(name+"对"+h1.name+"和"+h2.name+"分别进行了攻击");
	}

	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		ADHero bh = new ADHero();
		bh.name = "赏金";
		
		ADHero h1 = new ADHero();
		h1.name = "盖伦";
		
		Jicheng h2 = new Jicheng();
		h2.name = "提莫";
		
		bh.attack(h1);
		bh.attack(h1,h2);

	}

}

可变数量的参数

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

public void attack(Jicheng h1)

public void attack(Jicheng h1,Jicheng h2)

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

这时，可以采用可变数量的参数
只需要设计一个方法

public void attack(Jicheng ...jichengs)

即可代表上述所有的方法了
在方法里，使用操作数组的方式处理参数jichengs即可

package leiAndduixiang;

public class ADHero extends Jicheng
{
	public void attack()
	{
		System.out.println(name+"进行了一次攻击，但是不知道目标");
		
	}
	
	//可变数量的参数
	public void attack(Jicheng...jichengs)
	{
		for (int i =0;i<jichengs.length;i++)
		{
			System.out.println(name+"攻击了"+jichengs[i].name);
		}
	}
//	public void attack(Jicheng h1)
//	{
//		System.out.println(name+"对"+h1.name+"进行了一次攻击");
//	}
//	public void attack(Jicheng h1,Jicheng h2)
//	{
//		System.out.println(name+"对"+h1.name+"和"+h2.name+"分别进行了攻击");
//	}

	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		ADHero bh = new ADHero();
		bh.name = "赏金";
		
		Jicheng h1 = new Jicheng();
		h1.name = "盖伦";
		
		Jicheng h2 = new Jicheng();
		h2.name = "提莫";
		
		bh.attack(h1);
		bh.attack(h1,h2);

	}

}

练习-治疗

设计一个类Support (辅助英雄)继承Hero，提供一个heal(治疗)方法
对Support的heal方法进行重载

heal() 
heal(Jicheng h) //为指定的英雄加血
heal(Jicheng h, int hp) //为指定的英雄加了hp的血

package leiAndduixiang;

public class Support extends Jicheng
{
	public void heal()
	{
		System.out.println("为"+name+"加血");
		
	}
	public void heal(Jicheng h)
	{
		System.out.println("为"+h.name+"加血");
	}
	public void heal(Jicheng h,int hp)
	{
		System.out.println("为"+h.name+"加了"+hp+"的血");
	}
	

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Support s = new Support();
		
		Jicheng h = new Jicheng();
		h.name = "提莫";
//		h.hp = 300;
		
		s.heal(h);
		s.heal(h, 300);

	}

}

构造方法

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

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

什么是构造方法

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

package leiAndduixiang;

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(){

}

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

package leiAndduixiang;

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 teemo =  new Hero(); //无参的构造方法“木有了”
    }  
      
}

构造方法的重载

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

public class Hero {
       
    String name; //姓名
       
    float hp; //血量
       
    float armor; //护甲
       
    int moveSpeed; //移动速度
       
    //带一个参数的构造方法
    public Hero(String heroname){ 
        name = heroname;
    }
     
    //带两个参数的构造方法
    public Hero(String heroname,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

package leiAndduixiang;

public class Hero {
    
    String name; //姓名
       
    float hp; //血量
       
    float armor; //护甲
       
    int moveSpeed; //移动速度
       
    //带一个参数的构造方法
    public Hero(String heroname){ 
        name = heroname;
    }
     
    //带两个参数的构造方法
    public Hero(String heroname,float herohp){ 
        name = heroname;
        hp = herohp;
    }
    
    //带四个参数的构造方法
    public Hero(String heroname,float heroHp,float heroArmor,int heroMoveSpeed)
    {
    	name = heroname;
    	hp = heroHp;
    	armor = heroArmor;
    	moveSpeed = heroMoveSpeed;
    }
       
    public static void main(String[] args) {
        Hero garen =  new Hero("盖伦"); 
        Hero teemo =  new Hero("提莫",383);
        Hero nvjing = new Hero("女警",450,120,300);
    }
     
}

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);
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }
 
    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);
         
        System.out.println(teemo.name);
         
    }
      
}

习-构造方法(this)

参考练习-构造方法设计一个构造方法,但是参数名称不太一样，分别是
String name
float hp
float armor
int moveSpeed

不仅如此，在这个构造方法中，调用这个构造方法

public Hero(String name,float hp)

package leiAndduixiang;

public class This {
    
    String name; //姓名
        
    float hp; //血量
        
    float armor; //护甲
        
    int moveSpeed; //移动速度
        
    //带一个参数的构造方法
    public This(String name){
        System.out.println("一个参数的构造方法");
        this.name = name;
    }
      
    //带两个参数的构造方法
    public This(String name,float hp){
        this(name);
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }
    
    //带四个参数的构造方法
    public This(String name,float hp,float armor,int moveSpeed)
    {
    	this(name,hp);
    	System.out.println("带四个参数的构造方法");
    	this.armor = armor;
    	this.moveSpeed = moveSpeed;
    	
    }
 
    public static void main(String[] args) {
    	This teemo =  new This("提莫",383);
         
        System.out.println(teemo.name);
        
        This Gailun = new This("盖伦",3868,450,300);
        System.out.println(Gailun.moveSpeed);
         
    }
      
}

传参

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

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

基本类型传参

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

package leiAndduixiang;

public class Chuancan
{
	String name;
	float hp;
	float armor;
	int moveSpeed;
	
	//构造函数
	public Chuancan()
	{
		
	}
	//方法：回血
	public void huixue(int xp)
	{
		hp = hp + xp;
		//回血完毕，血瓶为0
		xp = 0;
	}
	
	public Chuancan(String name,float hp)
	{
		this.name = name;
		this.hp = hp;
	}

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Chuancan teemo = new Chuancan("提莫",389);
		
		int xueping = 100;
		
		teemo.huixue(xueping);
		
		System.out.println(xueping);

	}

}

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

包

规划在同一个包下

Hero,ADHero 规划在一个包，叫做charactor（角色）
Item,Weapon规划在另一个包下，叫做 property(道具)
在最开始的地方声明该类所处于的包名

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

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

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

成员变量有四种修饰符

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修饰属性
自身：是可以访问的
同包子类：不能继承
不同包子类：不能继承
同包类：不能访问
其他包类：不能访问

红色字体，表示不可行

private 私有的

package charactor;
 
import property.Weapon;
 
public class Hero {
 
    //属性id是private的，只有Hero自己可以访问
    //子类不能继承
    //其他类也不能访问
    private int id;
     
    String name;
 
    float hp;
 
    float armor;
 
    int moveSpeed;
 
    public void equip(Weapon w) {
 
    }
 
}

package/friendly/default 不写

没有修饰符即代表package/friendly/default
float maxHP; 血量上限

package/friendly/default 不写

package charactor;
 
import property.Weapon;
 
public class Hero {
    private int id;
 
    String name;
 
    // 无修饰符的属性 hp
    // 自己可以访问
 
    // 同包子类可以继承
    // 不同包子类不能继承
 
    // 同包类可以访问
    // 不同包类不能访问
    float hp;
 
    float armor;
 
    int moveSpeed;
 
    public void equip(Weapon w) {
 
    }
 
}

protected 受保护的

受保护的修饰符
protected float hp; 血量

protected 受保护的

package charactor;
 
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; 姓名
任何地方，都可以访问

public 公共的

package charactor;
 
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 charactor;
 
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

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

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

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

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

练习-类属性

通过garen.copyright修改其值

garen.copyright = "Blizzard Entertainment Enterprise"；

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

有变化，因为共享copyright。

类方法

类方法：又叫做静态方法

对象方法：又叫实例方法，非静态方法

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

package charactor;
 
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();
           teemo.name = "提莫";
            
           //无需对象，直接通过类调用
           Hero.battleWin();
         
    }
}

调用类方法

和访问类属性一样，调用类方法也有两种方式
1. 对象.类方法

garen.battleWin();

2. 类.类方法

Hero.battleWin();

练习-类方法

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

在类方法中直接调用对象方法是不对的，只有先在类方法中新建一个对象才能正常调用。

属性初始化

对象属性初始化

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

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

类属性初始化

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

package charactor;
 
public class Hero {
    public String name;
    protected float hp;
    float maxHP;
     
    //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化
     
    static{
        itemCapacity = 6;//静态初始化块 初始化
    }
     
    public Hero(){
         
    }
     
    public static void main(String[] args) {
        System.out.println(Hero.itemCapacity);
    }
     
}

练习-属性初始化

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

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

package charactor;
 
public class Hero {
    public String name = "some hero"; 
     
    public Hero(){
        name = "one hero";
    }
    {
        name = "the hero";
    }
     
}

声明》初始化块》构造初始化

单例模式

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

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

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

package charactor;
 
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的时候，才会创建实例

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

package charactor;
 
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方法，返回第二步的静态属性

枚举类型

预先定义的常量

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

public enum Season {

SPRING,SUMMER,AUTUMN,WINTER

}

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

注：因为是常量，所以一般都是全大写

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个季节）

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

遍历枚举

借助增强型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语句，把每种枚举常量输出为中文字符串

package charactor;

public class TestHerotype {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HeroType h=HeroType.tank;
        switch(h) 
        {
        case tank :
            System.out.print("坦克 ");
        case wizard :
            System.out.print("法师 ");
        case assassin :
            System.out.print("刺客 ");
        case assist :
            System.out.print("辅助 ");
        case warrior :
            System.out.print("近战 ");
        case ranged :
            System.out.print("远程 ");
        case push :
            System.out.print("推进 ");
        case farming :
            System.out.print("打野 ");
            break;
        }

	}

}


package charactor;

public enum HeroType {
    tank,wizard,assassin,assist,warrior,ranged,push,farming;
}