后端学习记录~~JavaSE篇（Module07-面向对象基础 ~下②)

7.2 枚举

7.2.1 概述

枚举类型本质上也是一种类，只不过是这个类的对象是固定的几个，而不能随意让用户创建。

JDK 1.5之前，自定义

JDK 1.5之后，支持enum关键字来快速定义枚举类型

 7.2.2 枚举的要求和特点

7.2.2.1 JDK1.5之前

public class Season{
	public static final Season SPRING = new Season();
	public static final Season SUMMER = new Season();
	public static final Season AUTUMN = new Season();
	public static final Season WINTER = new Season();
	
	private Season(){
		
	}
	
	public String toString(){
		if(this == SPRING){
			return "春";
		}else if(this == SUMMER){
			return "夏";
		}else if(this == AUTUMN){
			return "秋";
		}else{
			return "冬";
		}
	}
}

public class TestSeason {
	public static void main(String[] args) {
		Season spring = Season.SPRING;
		System.out.println(spring);
	}
}

7.2.2.2 JDK1.5之后(要求和特点)

1. 枚举的常量对象必须在枚举类的首行（常量 建议全部大写）
2. 常量列表后无其它代码可省略“ ； ”，否则不能
3. 默认private 的无参构造 如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数
4. 默认继承java.lang.Enum类，因此不能再继承其他的类型
5. JDK1.5之后的switch提供支持枚举类型，case后面可以写枚举常量名
6. 枚举其他属性建议声明为final（常量逻辑意义上不可变）

7.2.3、枚举类型常用方法

1.String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
2.String name():返回的是常量名（对象名）
3.int ordinal():返回常量的次序号，默认从0开始
4.枚举类型[] values():返回该枚举类的所有的常量对象，返回类型是当前枚举的数组类型，是一个静态方法
5.枚举类型 valueOf(String name)：根据枚举常量对象名称获取枚举对象

7.3 包装类

7.3.1 包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而当要使用只针对对象设计的API或新特性（例如泛型），那么基本数据类型的数据就需要用包装类来包装。

7.3.2 装箱与拆箱

装箱：基本数据类型 ==>包装类对象

Integer obj1 = new Integer(4);//使用构造函数函数
Integer obj2 = Integer.valueOf(4);//使用包装类中的valueOf方法

拆箱：包装类对象  ==>  基本数据类型

Integer obj = new Integer(4);
int num1 = obj.intValue();

JDK1.5之后，可以自动装箱与拆箱。

注意：只能与自己对应的类型之间才能实现自动装箱与拆箱。

7.3.4 包装类对象的特点

1、包装类缓存对象

2、类型转换问题

3、包装类对象不可变

/*
     * 方法的参数传递机制：
     * （1）基本数据类型：形参的修改完全不影响实参
     * （2）引用数据类型：通过形参修改对象的属性值，会影响实参的属性值
     * 这类Integer等包装类对象是“不可变”对象，即一旦修改，就是新对象，和实参就无关了
     */

    public static void main(String[] args) {
        int num1 = 1;
        int num2 = 2;
        System.out.println(num1 == num2);

        Integer objNum1 = 1;
        Integer objNum2 = 1;
        Integer objNum3 = 128;
        Integer objNum4 = 128;
        System.out.println(objNum1 == objNum2);
        System.out.println(objNum3 == objNum4);

        Integer objNum5 = new Integer(30);
        Integer objNum6 = new Integer(30);
        System.out.println(objNum5 == objNum6);

        Integer objNum7 = new Integer(20);
        Integer objNum8 = new Integer(20);
        System.out.println(objNum7 == objNum8);
        System.out.println(objNum5.equals(objNum6));

        int m1 = 1;
        Integer m2 = 1;
        int[] arrM3 = {1};
        addChange(m1,m2,arrM3);

        System.out.println(m1);
        System.out.println(m2);
        System.out.println(arrM3[0]);

    }
    public static void addChange(int a1,Integer a2,int[] a3){
        a1++;
        a2++;
        a3[0]++;
        System.out.println(a1);
        System.out.println(a2);
    }

public static void main(String[] args) {
    System.out.println("int类型的最大值：" + Integer.MAX_VALUE);
    System.out.println("int类型的最小值：" + Integer.MIN_VALUE);
    System.out.println("=========");
    System.out.println("long类型的最大值：" + Long.MAX_VALUE);
    System.out.println("long类型的最小值：" + Long.MIN_VALUE);
    System.out.println(Integer.toBinaryString(20));
    System.out.println(Integer.toOctalString(20));
    System.out.println(Integer.toHexString(20));
    System.out.println("---------");
    String str1 = "Hello";
    String str2 = "Hello123";
    String str3 = "123Hello";
    String str4 = "123";

    System.out.println(Integer.parseInt(str4));
    String str5 = "123.45";
    double d1 = Double.parseDouble(str5);
    double d2 = Double.valueOf(str5);
    System.out.println(d1);
    System.out.println(d2);

    char cha1 = 'a';
    char cha2 = Character.toUpperCase(cha1);
    char cha3 = 'A';
    char cha4 = Character.toLowerCase(cha2);
    System.out.println(cha2);
    System.out.println(cha4);

    double a = 10;
    double b = 15;
    System.out.println(Double.compare(a,b));


}

7.4 抽象类

7.4.1 由来

抽象：即不具体、或无法具体

公共父类只有方法签名 没有方法体（此种方法称之为抽象方法），包含抽象方法的类必须是抽象类

7.4.2 语法格式

• 抽象方法：被abstract修饰没有方法体的方法。

• 抽象类：被abstract修饰的类。

【权限修饰符】 abstract class 类名{
    
}
【权限修饰符】 abstract class 类名 extends 父类{
    
}

7.4.3 注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

   理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类中，也有构造方法，是供子类创建对象时，初始化父类成员变量使用的。

   理解：子类的构造方法中，有默认的super()或手动的super(实参列表)，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

   理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

   理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

7.4.4 修饰符一起使用问题？

 

不能和abstract一起使用的修饰符？

（1）abstract和final不能一起修饰方法和类

（2）abstract和static不能一起修饰方法

（3）abstract和native不能一起修饰方法

（4）abstract和private不能一起修饰方法

static和final一起使用：

（1）修饰方法：可以，因为都不能被重写

（2）修饰成员变量：可以，表示静态常量

（3）修饰局部变量：不可以，static不能修饰局部变量

（4）修饰代码块：不可以，final不能修改代码块

（5）修饰内部类：可以一起修饰成员内部类，不能一起修饰局部内部类