- 什么是Java中的引用?
- 什么是Java中的继承
- 什么是Java方法重载
- 怎么使用Java构造方法
- Java中的this是什么意思?
- Java中的传参详解
- Java中的包package
- Java的四种访问修饰符
- 类属性
- 类方法
- 属性初始化
- 单例模式
- 枚举类型
什么是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代表当前对象

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,那么到底什么情况该用什么修饰符呢?
- 属性通常使用private封装起来
- 方法一般使用public用于调用
- 会被子类继承的方法,通常使用protected
- 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);
}
}
访问类属性
访问类属性有两种方式
- 对象.类属性
teemo.copyright; - 类.类属性
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();
}
}
调用类方法
和访问类属性一样,调用类方法也有两种方式
- 对象.类方法
garen.battleWin(); - 类.类方法
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种
- 声明该属性的时候初始化
- 构造方法中初始化
- 初始化块
package character;
public class Hero{
public String name = "some hero";//声明该属性的时候初始化
protected float hp;
float maxHP;
{
maxHP = 200;//初始化块
}
public Hero(){
hp = 100;//构造方法中初始化
}
}
类属性初始化
类属性初始化有2种
- 声明该属性的时候初始化
- 构造方法中初始化
- 初始化块
package character;
public class Hero{
public String name = "some hero";//声明该属性的时候初始化
protected float hp;
float maxHP;
{
maxHP = 200;//初始化块
}
public Hero(){
hp = 100;//构造方法中初始化
}
}
类属性初始化
类属性初始化有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);
}
}
什么时候使用饿汉式,什么时候使用懒汉式
饿汉式是立即加载的方法,无论是否会用到这个对象,都会加载 如果在构造方法里写了性能消耗较大,占时较久的代码,比如建立与数据库的连接,那么就会在启动的时候感觉稍微有些卡顿。
懒汉式,是延迟加载的方法,只有使用的时候才会加载。并且有线程安全的考量(这里暂不对线程展开) 使用懒汉模式,在启动的时候,会感觉到比饿汉式略快,因为并没有做对象实例化。但是在第一次调用的时候,会进行实例化操作,感觉上就略慢。
(简单来说就是类属性何时初始化有区别)
单例模式三元素
这个是面试时候经常会考的点,面试题通常的问法是:
什么是单例模式
回答的时候,要答到三元素
- 构造方法私有化
- 静态属性指向实例
- 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;
}
}
}
}