java学习（类和对象）

引用

如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。
用new创建类的对象。

Hero h = new Hero();
//h就是引用

• 多个引用可以指向同一个对象。
• 一个引用不能指向多个对象。

继承

声明类的时候使用extends继承

重载

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

• 可变数量的参数

public void attack(Hero... heros) {
        for (int i = 0; i < heros.length; i++) {
            System.out.println(name + " 攻击了 " + heros[i].name);
        }
    }

构造方法

通过一个类创建一个对象的过程叫实例化。
实例化是通过调用构造方法实现的。

构造方法的方法名和类名一样，在实例化对象的时候必然调用构造方法。

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

• 如果没有设计有参的构造方法，系统会默认提供一个无参构造方法。
• 构造方法也可以重构。

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访问属性

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调用其他构造方法

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

包 package

• 把比较接近的类，规划在同一个包下
• 在类最开始的地方，声明该类所处于的包名
• 要使用其他包中的类，必须import

访问修饰符

成员变量的四种访问修饰符

• private 私有的
• package/friendly/default 不写
• protected 受保护的
• public 公有的

类间关系
自身、同包子类、不同包子类、同包类、其他类（不同包也没有继承关系）

	自身	同包子类	同包类	不同包子类	其他类
private	可以访问	不能继承	不能访问	不能继承	不能访问
package	可以访问	可以继承	可以访问	不能继承	不能访问
protected	可以访问	可以继承	可以访问	可以继承	不能访问
public	可以访问	可以继承	可以访问	可以继承	可以访问

使用访问修饰符的一般原则：

1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. package用的不多

static关键字

静态属性（类属性）

• static修饰的属性叫静态属性，也叫类属性。
• 所有对象的共享这个类的静态属性。
• 静态属性可以用类.属性直接访问

静态方法

• static修饰的方法叫静态方法
• 静态方法不需要对象存在就可以访问

单例模式

单例模式也叫Singleton模式，指一个类在一个JVM中只能有一个实例存在。

饿汉式单例模式

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

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

//TestGiantDragon.java
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的时候，才会创建实例
• 懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量。
• 使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

//GiantDragon.java
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;
    }      
}

//TestGiantDragon.java
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方法，返回第二步的静态属性