Java学习笔记(十三)

标签：Java name 十三 System 笔记 println Integer public out

7.6 枚举类

1、什么是枚举类?
枚举类是指一种特殊的类，这种类的对象只有有限的固定的几个常量对象。

2、什么情况会用枚举类呢？
例如：Month类，Week类等等，
他们的对象应该是固定的有限的几个。
Month类：12个对象
Week类:7个对象
Season（季节）类：4个对象

3、如何声明枚举类呢？
在JDK1.5之前：
(1)构造器私有化
(2)在枚举类的内部提前创建好几个固定的常量对象

在JDK1.5及其之后，简化了枚举类的声明：
【修饰符】 enum 枚举类{
常量对象列表
}
【修饰符】 enum 枚举类{
常量对象列表;
其他成员列表
}
说明：如果常量对象列表后面没有其他成员，;可以省略。
如果常量对象列表后面有其他成员，必须加;分隔。

4、enum声明的枚举类的特点
（1）构造器默认私有化
（2）不能用extends继承别的类，它的默认直接父类是java.lang.Enum类，
根父类仍然是Object。
（3）它也不能有子类。
（4）枚举类的所有对象必须在常量对象列表列出来，
如果常量对象只写名字，表示调用无参构造创建的对象，
如果常量对象名后面加(实参列表)，表示调用有参构造创建的对象
（5）枚举类中通常不声明其他的成员变量，当然也可以声明成员变量，
“建议”成员变量使用final声明。
因为枚举类的对象都是常量对象，通常属性也是不建议修改的。

5、枚举类的方法
（1）枚举类可以扩展自己的方法（根据需求定）
（2）枚举类也从Enum父类中继承了一些方法
String name(); 返回常量对象名
int ordinal(); 返回下标，从0开始
int compareTo(E o) ：用于枚举对象比较大小用的
String toString()：默认返回常量对象名，当然我们可以继续重写它
。。。
（3）编译器会给枚举类增加两个静态方法
static 枚举类名 valueOf(String name)
static 枚举类名[] values()

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 String name;

    private Season(){}//构造器私有化
    private Season(String name){this.name = name;}//构造器私有化

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class TestSeason {
    public static void main(String[] args) {
//        Season s = new Season();//构造器私有化之后，外面是无法new对象。

        Season spring = Season.SPRING;//得到一个Season类的对象，是春天对象
        System.out.println(spring);
    }
}

public enum Week{
    MONDAY,//表示调用无参构造创建的对象
    TUESDAY("星期二"),//表示调用有参构造创建的对象
    WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;

    private final String description;
    Week(){
        description = "";
    }
    Week(String description){
        this.description = description;
    }

    @Override
    public String toString() {
        return name() + "->" +  description ;
    }
}

import org.junit.Test;
import java.util.Scanner;

public class TestWeek {
    @Test
    public void test1(){
        Week w = Week.SUNDAY;
        System.out.println(w.name());//从父类继承的name()
        System.out.println(w.ordinal());//从父类继承的ordinal()
        System.out.println(w);//自动调用toString
    }

    @Test
    public void test2(){
        Week w1 = Week.SUNDAY;
        Week w2 = Week.FRIDAY;

//        System.out.println(w1 > w2);//错误，地址值不能比较大小
        System.out.println(w1.compareTo(w2));//返回的结果是int值
        /*
        正整数：说明w1 > w2
        负整数：说明w1 < w2
        0：说明w1 = w2
         */
    }

    @Test
    public void test3(){
        Week w = Week.TUESDAY;
        System.out.println(w.name());//从父类继承的name()
        System.out.println(w.ordinal());//从父类继承的ordinal()
        System.out.println(w);//自动调用toString
    }

    @Test
    public void test4(){
        Week[] all = Week.values();
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
    }

    @Test
    public void test5(){
        Scanner input = new Scanner(System.in);
        System.out.print("请输入星期的单词：");
        String name = input.next();

        name = name.toUpperCase();//把里面的单词全部转为大写的

        Week week = Week.valueOf(name);
        System.out.println(week);
        input.close();
    }
}

Java学习笔记(十三)_Test

Java学习笔记(十三)_包装类_02

7.7 包装类

7.7.1 包装类概述

1、什么是包装类？
包装类是基本数据类型对应的引用数据类型。
基本数据类型和空类型包装类
byte <-> Byte
short <-> Short
int <-> Integer
long <-> Long
float <-> Float
double <-> Double
char <-> Character
boolean <-> Boolean
void <-> Void

2、为什么要有包装类呢？
Java是面向对象的语言，很多新特性语法，API都只针对对象设计的，
不支持基本数据类型，所以程序中用基本数据类型表示的地方，需要换成包装类的对象。

例如：后面要学习的泛型
后面要学习的集合

3、装箱和拆箱
装箱：把基本数据类型的数据包装为包装类对象
拆箱：把包装类的对象拆解为基本数据类型的数据

在JDK1.5之前，装箱和拆箱需要手动进行，必须调用方法来完成。
在JDK1.5之后，编译器进行了升级，支持自动装箱和自动拆箱。
注意：自动装箱和自动拆箱只支持对应类型之前。

@Test
    public void test1(){
        //手动装箱
        int num = 10;
        Integer obj1 = new Integer(num);
        Integer obj2 = Integer.valueOf(num);

        //手动拆箱
        int a = obj1.intValue();
    }

    @Test
    public void test2(){
        //自动装箱
        int num = 10;
        Integer obj1 = num;

        //自动拆箱
        int a = obj1;
    }

    @Test
    public void test3(){
        int num = 10;
//        Double d = num;//错误，不支持int和Double的自动装箱

        Double d1 = 1.0;//可以
//        Double d2 = 1;//错误，1是int
        Double d2 = 1d;//可以，数字后面加D或d，表示是double类型
    }

7.7.2 包装类API

4、包装类有一些好用的API方法
（1）支持与字符串之间的类型转换（***）
int Integer.parseInt(字符串)
double Double.parseDouble(字符串)
long Long.parseLong(字符串)
...

（2）获取某些类型的边界值（最大，最小值）
Integer.MAX_VALUE
Integer.MIN_VALUE
....

（3）转大小写
Character.toUpperCase(字符)：转大写
Character.toLowerCase(字符)：转小写

（4）比较大小（***）
int Double.compare(double,double)
int Integer.compare(int,int)

@Test
    public void test4(){
        String str = "124";
//        int num = (int)str;//错误，不能通过强制类型转换完成
        int num = Integer.parseInt(str);
    }

    @Test
    public void test5(){
        int max = Integer.MAX_VALUE;
        int min = Integer.MIN_VALUE;
    }

    @Test
    public void test6(){
        char letter = 'a';
        //转为大写
        char c1 = (char)(letter - 32);
        char c2 = Character.toUpperCase(letter);

        System.out.println("c1 = " + c1);
        System.out.println("c2 = " + c2);
    }

    @Test
    public void test7(){
        char letter = 'A';
        //转为大写
        char c1 = (char)(letter + 32);
        char c2 = Character.toLowerCase(letter);

        System.out.println("c1 = " + c1);
        System.out.println("c2 = " + c2);
    }

    @Test
    public void test8(){
        //比较两个员工对象的大小
        Employee e1 = new Employee("张三",15000);
        Employee e2 = new Employee("李四",18000);

//        System.out.println(e1 > e2);//错误
        System.out.println(e1.compareTo(e2));
    }

public class Employee implements Comparable {
    @Override
    public int compareTo(Object o) {
        //按照薪资比较大小
/*        Employee other = (Employee) o;
        if(this.salary > other.salary){
            return 1;
        }else if(this.salary < other.salary){
            return -1;
        }
        return 0;*/

        return Double.compare(this.salary, ((Employee)o).salary);
    }

    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    } 
}

7.7.3 包装类特点

5、包装类对象特点
（1）包装类对象不可变
A：包装类对象可以共享，只是部分被缓存了
B：当形参是包装类型时，形参修改和实参无关

（2）部分包装类对象被缓存在常量池中
Byte,Short,Integer,Long：-128~127
Character：0-127
Boolean：true和false
Float和Double：没有缓存对象

    @Test
    public void test9(){
        Integer i1 = 1;
        Integer i2 = 1;

        System.out.println(i1 == i2);
    }

    @Test
    public void test10(){
        Integer i1 = 128;
        Integer i2 = 128;

        System.out.println(i1 == i2);
    }

    @Test
    public void test11(){
        Integer i = 1;
        System.out.println("i =" + i);
        change(i);
        System.out.println("i =" + i);

        i++;
        System.out.println("i = " + i);

        i++;
        System.out.println("i = " + i);
    }
    public void change(Integer i){
        i++;
    }

7.7.4 包装类对象比较

6、包装类对象的比较相等、大小等
(1)==
A：两个同种类型的包装类对象 == ，比较地址值
B：两个不同类型的包装类对象 ==，编译报错
C：一个包装类一个基本数据类型==，比较数据值。
包装类对象会自动拆箱为基本数据类型的值，然后按照基本数据类型的值进行比较。

（2）包装类对象比较相等也可以通过equals()方法比较
boolean 包装类对象1.equals(包装类对象2)：比较内容

（3）>,<,>=,<=等比较两个包装类对象时，会自动拆箱为基本数据类型比较

7、equals方法是Object类中声明的，所有类型都可以重写这个方法。
包装类、String类等它们已经重写了。
我们自己写的类也可以重写equals方法

如果没有重写equals方法，按照Object类的equals方法，也是比较地址值，等价于==。
如何重写，快捷键，Alt+Insert，选择

    @Test
    public void test12(){
        Integer i1 = 1;
        Integer i2 = 1;
        System.out.println(i1 == i2);//比较地址值true
                                //i1和i2是指向缓存对象，同一个对象

        Integer i3 = 128;
        Integer i4 = 128;

        System.out.println(i3 == i4);//比较地址值false
                            //128超过缓存范围，用就new，它俩的地址不同
    }

    @Test
    public void test13(){
        Integer i = 1;
        Double d = 1.0;
//        System.out.println(i == d);
        //编译报错，因为它们是不同类型的对象，不是父子类关系，无法比较地址

        String s = "hello";
//        System.out.println(s == i);//编译报错，String和Integer不是同种类型，也不是父子类
        Object obj = new Object();
        System.out.println(s == obj);//父子类关系的变量可以比较 false
    }

    @Test
    public void test14(){
        Integer i = 1;
        int j = 1;
        System.out.println(i==j);//true

        Integer m = 200;
        int n = 200;
        System.out.println(m == n);//true

        Integer x = 1;
        double d = 1.0;
        System.out.println(x == d);//true
    }

    @Test
    public void test15(){
        Integer i1 = 200;
        Integer i2 = 200;
        System.out.println(i1 == i2);//比较地址值  false
        System.out.println(i1.equals(i2));//比较内容，就是数据值  true
    }

    @Test
    public void test16(){
        String str1 = new String("hello");
        String str2 = new String("hello");

        System.out.println(str1 == str2);//比较地址值  false
        System.out.println(str1.equals(str2));//比较内容，true
    }

    @Test
    public void test17(){
        String str1 = "hello";
        String str2 = "hello";

        System.out.println(str1 == str2);//比较地址值  true
        System.out.println(str1.equals(str2));//比较内容，true
    }

    @Test
    public void test18(){
        Integer i1 = 200;
        Integer i2 = 180;

        System.out.println(i1 > i2);
    }

    @Test
    public void test19(){
        Employee e1 = new Employee("张三",15000);
        Employee e2 = new Employee("张三",15000);

        System.out.println(e1 == e2);//比较地址值 false
        System.out.println(e1.equals(e2));//false  or true，要看是否重写
    }

import java.util.Objects;

public class Employee implements Comparable {
    @Override
    public int compareTo(Object o) {
        //按照薪资比较大小
/*        Employee other = (Employee) o;
        if(this.salary > other.salary){
            return 1;
        }else if(this.salary < other.salary){
            return -1;
        }
        return 0;*/

        return Double.compare(this.salary, ((Employee)o).salary);
    }

    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, salary);
    }
}

第8章异常

8.1 异常的概念

1、什么是异常？
异常：不正常

以下情况不是异常：
（1）编译错误，语法错误
（2）逻辑错误：编译通过，能正常运行，但是结果不对

什么是异常呢？
编译要通过，正常情况下程序可以正常运行，结果也正确，
只是在某些特殊情况下，该程序会运行报错，导致程序崩溃。

2、Java中如何表示异常的呢？
Java中是用对象来表示异常的。
当某句代码遇到了“特殊情况/异常情况”时，Java会停下来，
并且创建一个对应类型的对象，
并且“抛”出。
如果没有编写“捕获”这个异常对象的代码，那么程序就会“挂”掉。

import org.junit.Test;

import java.util.Scanner;

public class TestException {
    public static void main(String[] args) {
//        System.out.println("a =" + a);//编译错误，语法错误，不是异常

        int x = 1;
        int y = 2;
        System.out.println("最大值：" + max(x,y));
    }

    /*
   返回a和b中的最大值
    */
    public static int max(int a, int b){
        //逻辑错误
        return a < b ? a : b;//a>b写成了a<b
    }

    @Test
    public void test2(){
        Scanner input = new Scanner(System.in);
        System.out.print("请输入被除数：");
        int a = input.nextInt();

        System.out.print("请输入除数：");
        int b = input.nextInt();//当b==0时，发生ArithmeticException

        System.out.println("a/b=" + a/b);
        input.close();
    }
}

后面明天再写吧，五千多字是文章最低要求

标签：Java,name,十三,System,笔记,println,Integer,public,out
From： https://blog.51cto.com/u_16213911/7131713

7.6 枚举类

7.7 包装类

7.7.1 包装类概述

7.7.2 包装类API

7.7.3 包装类特点

7.7.4 包装类对象比较

第8章异常

8.1 异常的概念

相关文章

赞助商

阅读排行

Java学习笔记(十三)

7.6 枚举类

7.7 包装类

7.7.1 包装类概述

7.7.2 包装类API

7.7.3 包装类特点

7.7.4 包装类对象比较

第8章 异常

8.1 异常的概念

相关文章

赞助商

阅读排行

第8章异常