Java重新来过五（类和对象，）

一、类和对象

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

使用引用来代表（指向）一个对象，引用用来访问这个对象。

（一个引用同一时间，只能指向一个对象；一个对象可以有多个引用）

2、继承（属性）

3、方法重载：方法名一样，参数类型不一样（在同一个类里）

可变数量的参数：在方法里，使用操作数组的方式处理参数即可

public void attack(Hero... heros) {

for (int i = 0; i < heros.length; i++) {

System.out.println(name + " 攻击了 " + heros[i].name);

}

4、构造方法：

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

实例化是通过调用构造方法（构造器）实现的。

    // 方法名和类名一样（包括大小写）

    // 没有返回类型

    public Hero() { //这个无参的构造方法，如果不写，就会默认提供一个

        System.out.println("实例化一个对象的时候，必然调用构造方法");

    }

    public static void main(String[] args) {

        //实例化一个对象的时候，必然调用构造方法

        Hero h = new Hero();

    }

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

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

5、 this：this即代表当前对象

public void showAddressInMemory(){

System.out.println("打印this看到的虚拟地址："+this);

}

    //参数名和属性名一样
    //在方法体中，只能访问到参数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;
    }

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

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

6、传参：

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

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

类类型传参：

类类型又叫引用，可以改变方法外的类类型参数值

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

7、包package

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

8、访问修饰符

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

æ»ç»

属性通常使用private封装起来
方法一般使用public用于被调用
会被子类继承的方法，通常使用protected

作用范围最小原则

9、类属性：又叫做静态属性
对象属性：又叫实例属性，非静态属性

当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
与对象属性对比：
不同对象的对象属性的值都可能不一样。
比如盖伦的hp 和提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的

访问类属性：两种方式：对象.类属性类名.类属性（建议使用这个）

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

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

10、类方法

类方法：又叫做静态方法

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

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

访问类方法：两种方式：对象.类方法类名.类方法（建议使用这个）

类方法不随对象的改变而变化，对象方法随对象的改变而改变

11、属性初始化

对象属性初始化有3种：

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

类属性初始化有2种：

    //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化
     
    static{
        itemCapacity = 6;//静态初始化块 初始化
    }

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

饿汉式：无论如何都会创建一个实例

懒汉式：只有在调用getInstance的时候，才会创建实例

1. 构造方法私有化private GiantDragon(){ //私有化构造方法使得该类无法在外部通过new 进行实例化
2. 静态属性指向实例 private static GiantDragon instance; //一个类属性，用于指向一个实例化对象，暂指向null
3. public static的 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;
    }
      
}

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

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

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

看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式

13、枚举类：枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量

public enum Season {

SPRING,SUMMER,AUTUMN,WINTER

}

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

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

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

遍历枚举：使用增强for循环

for (Season s : Season.values()) {

System.out.println(s);

}