JAVA基础 类与对象（3）

JAVA基础 类与对象（3）

1.属性初始化
1.1对象属性初始化
对象属性初始化有3种

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

package pack1;

public class Person {
    private int a=100;//声明该属性的时候初始化
    private int b;
    private int c;
    //初始化块
    {
     b=100;
    }

    Person(){
        c=100;//在构造方法中初始化
    }
    
    //在构造方法中初始化
    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
}

1.2 类属性的初始化
类属性初始化有2种

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

package pack1;

public class Student {
    //静态方法
    public  static String name="小姚同学";//声明的时候 初始化
    char sex;
    //静态初始化块
    static {
        name="yzs";
    }
 } 

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

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

package pack1;

public class Person {
    //初始化顺序：类属性>对象属性>构造方法
    public String name = "some hero";//对象属性 2

    public Person(){//构造方法 3
        name = "one hero";
    }
    //类属性 1
    {
        name = "the hero";
    }

    public static void main(String args[]){
        Person p1=new Person();
        System.out.println(p1.name);//运行结果是one hero 最后执行
    }
 }   

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

2.1饿汉式单例模式
GiantDragon.java

package pack1;

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

testGiantDragon.java

package pack1;

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

运行结果

2.2懒汉式单例模式
懒汉式单例模式与饿汉式单例模式不同，只有在调用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);
    }
}

单例模式练习

//饿汉单例模式
public class Hero {
    //1.构造方法私有化
    private Hero(){}
    //2.类属性指向一个实例化对象
   private static Hero hero=new Hero();
    //3.静态方法返回类属性
    public  static Hero getHero(){
        return hero;
    }
  }  

package pack1;
//懒汉单例模式
public class Hero{
    private Hero(){}
    //类属性指向一个实例化对象 暂时指向null
    private static Hero hero;
   public  static Hero getHero(){
       //第一次访问的时候 发现hero没有指向任何对象 这时实例化一个对象
       if(null==hero)hero=new Hero();
       return hero;
   }
 }

3.枚举类型

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

package pack1;
public enum Season {
//常量 : 春 夏 秋 冬
    SPRING,SUMMER,AUTUMN,WINTER
}

testSeason.java

package pack1;

public class testSeason {
    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;
        }
    }
}

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

枚举类型可以很好地限定范围
3.3遍历枚举
借助增强型for循环，可以很方便的遍历一个枚举都有哪些常量

package pack1;

public class testSeason {
    public static void main(String[] args) {
        for (Season s : Season.values()) {
            System.out.println(s);
        }
     }
}