类与对象

1 类与对象

1.1 构造方法

方法名和类名一样（包括大小写）
没有返回类型
实例化一个对象的时候，必然调用构造方法

public class Test {

    String name;

    int age;

    String sex;

    // 构造方法  方法名与类名一样(包括大小写)

    // 没有返回类型

    public Test(){

       System.out.println("实例化一个对象");

    }

    public static void main(String[] args) {

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

       Test t =new Test();

    }

}

如果不写构造方法会默认调用它的无参构造方法

一旦提供了一个有参的构造方法 
同时又没有显式的提供一个无参的构造方法 

那么默认的无参的构造方法，就没有了,一般提供有参构造后,推荐手写提供一个无参构造

1.2 构造方法的重载

重载:方法名相同,参数列表不同(个数,类型,顺序)

public class Test {

    String name;

    int age;

    String sex;

    // 构造方法  方法名与类名一样(包括大小写)

    // 没有返回类型

    public Test(String name){

    }

    public Test(String name,int age){

    }

    public static void main(String[] args) {

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

       Test t1 =new Test("tom");

       Test t2 =new Test("serry",18);

    }

}

1.3 引用与=
=表示赋值的意思。
如果一个变量是类类型 比如 Test t = new Test(); 我们就管t叫做引用。
=不再是赋值的意思
=表示指向的意思
比如 Test t = new Test();这句话的意思是引用t，指向一个Test对象

1.4 访问修饰符

private 私有的 
default 不写 
protected 受保护的 
public 公共的 

1.5 属性初始化

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

public class Test {

    public String name="tom"; //声明属性的时候初始化

    protected int age;

    String sex;

    {

       age=20;  //初始化块

    }

    public Test(){

       sex="男"; //构造方法中初始化

    }

}

1.6 单例模式

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

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

懒汉式，是延迟加载的方式，只有使用的时候才会加载, 才会创建实例。 并且有线程安全的考量

使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。
看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式

单例模式三元素

1. 构造方法私有化
2. 静态属性指向实例

1.7 枚举类型

但是使用枚举，就能把范围限定在这四个季节当中,所以default判断没有了意义

public  enum Season{

    SPRING,SUMMER,AUTUMN,WINTER;

}

public class Test {

    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;

       default:

           System.out.println("没有这个季节");

           break;

       }

    }

}

遍历枚举

public  enum Season{

    SPRING,SUMMER,AUTUMN,WINTER;

}

借助增强型for循环，可以很方便的遍历一个枚举都有哪些常量

public class Test {

    public static void main(String[] args) {

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

           System.out.println(s);

       }

    }

}

小Test:遍历枚举并用Switch分类

public class Test {

    public static void main(String[] args) {

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

           System.out.println(s);

           switch (s) {

           case SPRING:

              System.out.println("春天");

              break;

           case SUMMER:

              System.out.println("夏天");

              break;

           case AUTUMN:

              System.out.println("秋天");

              break;

           case WINTER:

              System.out.println("冬天");

              break;

           default:

              break;

           }

       }      

    }

}