Java类和对象

1.类的继承：

使用 extends，可以继承父类的属性类型。

2.方法重载：

一样的方法名，根据传入的参数不同，自动选择不同的方法。
动态参数：

    public void attack(Hero ... heroes){
        for(Hero hero :heroes){
            System.out.println(name + "同时攻击了"+hero.name);
        }
    }

3.构造方法：

• 构造方法如果加上返回类型，那么只是一个普通方法。
• 构造方法也可以重载。
• 一旦提供了一个有参的构造方法，同时又没有显式的提供一个无参的构造方法，那么默认的无参的构造方法，就没有了。

4.this：

• 仅代表当前对象实例，写set方法和构造方法时，便于区别。
• 如果要在一个构造方法中，调用另一个构造方法，可以使用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;
    }

5.传参

Java中变量有两种类型，基本类型、类类型
基本类型：=是赋值的意思
类类型：=表示指向

6.包pachage

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

7.访问修饰符

• 作用范围最小原则

是否可以访问/继承	自身	同包子类	不同包子类	同包类	其他类
private	是	否	否	否	否
没有修饰符	是	是	否	是	否
protected	是	是	是	是	否
public	是	是	是	是	是

• 没有修饰符即代表package/friendly/default
• private:只有自己可以访问。
• 没有修饰符：一个包的都能访问。
• protected：一个包的，和其它包的子类都能访问。
• public：所有都能访问。

1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

8.类属性

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

访问类属性：

1. 对象.类属性
2. 类.类属性
   这两种方式都可以访问类属性，访问即修改和获取，但是建议使用第二种 类.类属性 的方式进行，这样更符合语义上的理解

9.类方法

类方法： 又叫做静态方法 ，方法被static修饰
对象方法： 又叫实例方法，非静态方法

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

调用类方法 与 访问类属性一样，可以通过对象和类调用。但是建议使用第二种 类.类方法 的方式进行，这样更符合语义上的理解。
Math.random()，random()就是一个类方法，直接通过类Math进行调用，并没有一个Math的实例存在。

• 什么时候设计对象方法，什么时候设计类方法：
  当一个方法中，访问了对象属性，那么只有存在一个对象的时候，该属性才有意义，那么该方法必须设计为对象方法。反之，如果一个方法没有调用任何对象属性，那么可以考虑设计为类方法。

10.属性初始化

对象属性初始化有3种：

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

类属性初始化有2种：

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

11.单例模式

单例模式又叫singleton模式，值得是一个类，在一个JVM里，只有一个实例存在。
饿汉式单例和懒汉式单例：

• 是立即加载的方式，无论是否会用到这个对象，都会加载。
  如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。
• 是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量。
  使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。
• 看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式。

单例模式三元素：

什么是单例模式？
1、构造方法私有化
2、静态属性指向实例
3、public static的getInstance方法，返回第二步的静态属性

12.枚举类型

• 枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量
  比如设计一个枚举类型 季节，里面有4种常量
  注：因为是常量，所以一般都是全大写

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

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

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