- 引用
如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。
#创建一个对象
new Hero();
#使用一个引用来指向这个对象
Hero h = new Hero();
引用有多个，但是对象只有一个。
#使用一个引用来指向这个对象
Hero h1 = new Hero();
Hero h2 = h1; //h2指向h1所指向的对象
Hero h3 = h1;
Hero h4 = h1;
Hero h5 = h4;
#h1,h2,h3,h4,h5 五个引用，都指向同一个对象
继承
extends方法重载
public void attack(Hero h1)
public void attack(Hero h1,Hero h2)
public void attack(Hero h1,Hero h2,Hero h3)
#多参数重载
public void attack(Hero ...heros){
for (int i = 0; i < heros.length; i++) {
System.out.println(name + " 攻击了 " + heros[i].name);
}
}
构造方法
方法名和类名一样（包括大小写）
没有返回类型，用于类的实例化
无参的构造方法，如果不写，就会默认提供一个。
一旦提供了一个有参的构造方法
同时又没有显式的提供一个无参的构造方法
那么默认的无参的构造方法，就消失了。this
我，当前对象
如果要在一个构造方法中，调用另一个构造方法，可以使用this()
#引用多this
this(name,hp);
- 引用与赋值
如果一个变量是基本类型，比如 int hp = 50;我们就直接管hp叫变量，=表示赋值的意思。
如果一个变量是类类型，比如 Hero h = new Hero();我们就管h叫做引用。
=不再是赋值的意思，=表示指向的意思
比如 Hero h = new Hero();这句话的意思是引用h，指向一个Hero对象。
7.类方法
//实例方法,对象方法，非静态方法
//必须有对象才能够调用
public void die(){
hp = 0;
}
//类方法，静态方法
//通过类就可以直接调用
#如果在某一个方法里访问了对象属性，那么这个方法，就必须设计为对象方法
#如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法
public static void battleWin(){
System.out.println("battle win");
}
#static中调用非类方法需要先在static内实例化对象
#java编译前会将static修饰的main预加载进方法区，没有static修饰的由于还没有加载到，
#所以访问不到，报错，也就是不可调用。
#如果将类实例化，则相当于加载static的同时实例化这个类，所以就可以正常访问。
- 初始化顺序
->属性声明初始化
->块初始化
->构造方法中初始化 - 单例模式
LOL里有一个怪叫大龙GiantDragon，只有一只，所以该类，只能被实例化一次，指的是一个类，在一个JVM里，只有一个实例存在。
1. 构造方法私有化
2. 静态属性指向实例
3. public static的 getInstance方法，返回第二步的静态属性
饿汉模式
public class GiantDragon {
//私有化构造方法使得该类无法在外部通过new 进行实例化
private GiantDragon(){
}
//准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
private static GiantDragon instance = new GiantDragon();
//public static 方法，提供给调用者获取12行定义的对象
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;
}
//调用
GiantDragon g1 = GiantDragon.getInstance();
饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。
如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。
懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的需求使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。
如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式
- 抽象类
区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public
静态
final的
即便没有显式的声明 - 内部类
在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类
内部类分为四种：
非静态内部类
非静态内部类可以访问外部类的方法和属性。
public class Hero {
private String name; // 姓名
float hp; // 血量
float armor; // 护甲
int moveSpeed; // 移动速度
// 非静态内部类，只有一个外部类对象存在的时候，才有意义
// 战斗成绩只有在一个英雄对象存在的时候才有意义
class BattleScore {
int kill;
int die;
int assit;
public void legendary() {
if (kill >= 8)
System.out.println(name + "超神！");
else
System.out.println(name + "尚未超神！");
}
}
public static void main(String[] args) {
Hero garen = new Hero();
garen.name = "盖伦";
// 实例化内部类
// BattleScore对象只有在一个英雄对象存在的时候才有意义
// 所以其实例化必须建立在一个外部类对象的基础之上
BattleScore score = garen.new BattleScore();
score.kill = 9;
score.legendary();
}
}
静态内部类
静态内部类不可以访问外部类的实例属性和方法
只能访问外部类的私有静态成员
public class Hero {
public String name;
protected float hp;
private static void battleWin(){
System.out.println("battle win");
}
//敌方的水晶
static class EnemyCrystal{
int hp=5000;
//如果水晶的血量为0，则宣布胜利
public void checkIfVictory(){
if(hp==0){
Hero.battleWin();
//静态内部类不能直接访问外部类的对象属性
System.out.println(name + " win this game");
}
}
}
public static void main(String[] args) {
//实例化静态内部类
Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
crystal.checkIfVictory();
}
}
匿名类
匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练
通常情况下，要使用一个接口或者抽象类，都必须创建一个子类
有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
这样的类，叫做匿名类。
public abstract class Hero {
String name; //姓名
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度
public abstract void attack();
public static void main(String[] args) {
ADHero adh=new ADHero();
//通过打印adh，可以看到adh这个对象属于ADHero类
adh.attack();
System.out.println(adh);
Hero h = new Hero(){
//当场实现attack方法
public void attack() {
System.out.println("新的进攻手段");
}
};
h.attack();
//通过打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名
System.out.println(h);
}
}
本地类
本地类可以理解为有名字的匿名类
内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。
本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环里等等地方
public abstract class Hero {
String name; //姓名
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度
public abstract void attack();
public static void main(String[] args) {
//与匿名类的区别在于，本地类有了自定义的类名
class SomeHero extends Hero{
public void attack() {
System.out.println( name+ " 新的进攻手段");
}
}
SomeHero h =new SomeHero();
h.name ="地卜师";
h.attack();
}
}
- 默认方法
默认方法是JDK8新特性，指的是接口也可以提供具体方法
public interface Mortal {
public void die();
default public void revive() {
System.out.println("本英雄复活了");
}
}
类、抽象类、接口（接口只是个类型）——简化概括
类继承--->子类完全继承父类特点
抽象类继承--->继承时抽象的部分不同的子类可以有不同的实现
接口继承--->所有成员在子类都可以有不同的实现
至于为什么要用接口而不是抽象类
这要看二者适用的情况
当个性大于共性时,适合接口,如鸟和飞机,适合抽象出一个飞的接口
当共性大于个性时,适合抽象类,如老鹰和麻雀,适合抽象出一个鸟的父类
另外接口可以实现多重继承,这也是一个特点
容易混淆的误区——实现抽象方法与重写普通方法 的本质
抽象方法与重写的目的都是为了实现多态，
相同点：两者方法体和参数都必须和父类保持一致，
不同点：抽象类没有方法体，重写有， 抽象类比重写更加灵活。
只不过抽象方法在父类中不需要写方法体，并且子类中必须重写该抽象方法。
所以说抽象方法其实就是重写的一种罢了。
抽象类的实现和正常类的重写没区别
接口的应用场景——继承、实现的选择
1.因为接口的属性和抽象方法默认是必须公开的（public）
所以如果有需要保护private(私有)的属性或者方法时，必须用继承一个类（抽象类也是类）
2.继承类(一般私有)只能继承一个（单继承），实现接口(公共)可以实现多个（多继承）
所以能用接口解决的问题，基本不用继承一个类(或抽象类)来解决
3.接口之所以提供默认方法，只是为了不用实现，直接可以用（提供方便而已，不要多想）
4.之所以会有抽象类这种类，只是为了在继承私有属性和方法的同时，子类约定好必须使用这个方法。因为继承的普通方法可以不用写出来，而抽象方法必须写出来（只是为了提醒程序员其中重点特殊的功能是什么）
所以如果需要继承父类私有属性的同时，又需要公共的特殊功能时，可以考虑抽象类
5.抽象类是对对象进行的抽象,而接口是一种行为规范
6.二者的选择
(1)优先选用接口，尽量少用抽象类
(2)需要定义子类的行为，又要为子类提供共性功能时才选择抽象类
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
