java枚举用中文作为对象名

Posted 2023-05-09

public enum EnT1 图书1,图书2,图书3;我这样定义了一个枚举，编译运行，到后面的调用都没有出现任何问题，我想问一下枚举用中文作为对象名合不合规范，有没有什么地反明确指出不能使用中文作为枚举的对象名，注意我说的是枚举，不是class。

参考技术A 没有，在编程语言里用中文会让人觉得你不专业哦，亲，还是用英文吧。本回答被提问者采纳 参考技术B 你都用了，那有什么问题。对象名可以使中文吧。
你这个应该不算对象名啊。追问

枚举也有构造器，也能通过构造器赋值，如下：
public enum EnT1
图书1("图书名称"),图书2("图书类别"),图书3("图书作者");
private EnT1(String name)
this.name=name;

private String name;

只是他的构造器只能是私有的，那么这个东西不叫对象应该叫什么啊？

追答

我也不大清楚啊，好像应该也叫对象名啊，但是感觉怪怪的。

枚举异常

1.访问权限修饰符 enum 枚举名{
//静态常量
常量A,常量B,常量C;

}
2.枚举只能给枚举对象赋值
枚举名 对象 = 枚举名.常量A;
对象存储的就是枚举值
3.switch...case形式
switch(对象|枚举名.常量A){
//枚举中定义的常量
case 常量A:
执行语句;
break;
........
}
通过反编译:
其实枚举即使一个特殊的类并且默认继承一个Enum的类
提供一些我们常用的方法 -->通过API中的Enum类就可以看到
两个隐藏方法values() --> 可以获取一个枚举中所有常量值的数组
valueOf("常量A")-->参数是一个字符串名就可以了 需要是枚举中常量的名字

所写的枚举常量 public static final 枚举类型 常量名;
构造方法私有化
枚举单利:
public enum 枚举名{
常量A;

}
可以在枚举中定能定义静态方法静态属性和成员方法和成员属性
枚举中可以定义抽象方法,但是若枚举中有枚举常量抽象方法需要定义在枚举常量的下面,并且必须实现这个抽象方法
常量是可以有自己的方法的形式的
public enum 枚举名{
A{
重写抽象方法
};
public abstract 返回值类型 方法名();


}


异常:
非正常发生的事情,不同于寻常
一个正常人,身体发热,去看医生,说不意思:你感冒了
ps:程序出问题了给的警告

/**
 * 
 */
package com.qfedu.Day15.Exception;

public class ExceptionDemo {

    public static void main(String[] args) {
        System.out.println("-----------------------begin-----------------------");
        int x = 9;
        int y = 0;
        try {
        //这段代码可能会出现异常
        int result = x/y;
        System.out.println("结果:"+result);
        //1.若能明确异常类型,就写当前异常类型
        //2.不知道异常类 --> Exception
        }catch(ArithmeticException e) {
            System.out.println("除数为0,出现了问题!!!!!!");
            
        }
        System.out.println("-------------------------end-------------------------");
            }

}

 

异常的种类:
编译时异常:在代码进行编译阶段,就会出现的异常信息
编译时异常必须处理,不处理程序会一直报错,若强行运行只有崩溃的结果
运行时异常:在代码执行阶段,出现异常就是运行时异常
1.在写代码时,就知道这段代码会出现一个异常进行一些处理
2.抛出异常后,在进行修改

/**
 * 
 */
package com.qfedu.Day15.Exception;

public class ExceptionDemo2 {

    public static void main(String[] args) {
//        String num1 = "10";
//        String num2 = "0";
//        try {
//        int i1 = Integer.parseInt(num1);
//        int i2 = Integer.parseInt(num2);
//        int result = i1/i2;
//        System.out.println(result);
//        }catch(NumberFormatException e) {
//            //打印异常信息 --> 打印系统所自订的异常信息
//            System.out.println(e.getMessage());
//        }catch (ArithmeticException e) {
//            /*
//             * java.lang.ArithmeticException: / by zero
//                at com.qfedu.Day15.Exception.ExceptionDemo2.main(ExceptionDemo2.java:23)
//             */
//            //打印跟中栈信息
//            e.printStackTrace();
//        }
        //如下语法需要注意
//        String num1 = "10";
//        String num2 = "0";
//        try {
//        int i1 = Integer.parseInt(num1);
//        int i2 = Integer.parseInt(num2);
//        int result = i1/i2;
//        System.out.println(result);
//        
//        }catch (ArithmeticException e) {
//            /*
//             * java.lang.ArithmeticException: / by zero
//                at com.qfedu.Day15.Exception.ExceptionDemo2.main(ExceptionDemo2.java:23)
//             */
//            //打印跟中栈信息
//            e.printStackTrace();
//        //Exception是父类---> 接收所有异常,剩余的子类异常就无法接收异常信息了    
//            //所以父类异常需要出现在子类异常的后面
//        }catch(Exception e) {
//            //打印异常信息 --> 打印系统所自订的异常信息
//            System.out.println(e.getMessage());
//        }
        //1.7中的新特性
        String num1 = "10";
        String num2 = "0";
        try {
        int i1 = Integer.parseInt(num1);
        int i2 = Integer.parseInt(num2);
        int result = i1/i2;
        System.out.println(result);
        //平级捕获异常 需要满足 父类不能出现在子类的前面
        }catch (ArithmeticException | NumberFormatException e) {
            //打印跟中栈信息
            e.printStackTrace();
        }
        
    }

}

/**
*
*/
package com.qfedu.Day15.Exception;

public class ExceptionDemo3 {

public static void main(String[] args) {
System.out.println("-----------------------begin-----------------------");
int x = 9;
int y = 0;
try {
//这段代码可能会出现异常
int result = x/y;
System.out.println("结果:"+result);
//1.若能明确异常类型,就写当前异常类型
//2.不知道异常类 --> Exception
}catch(ArithmeticException e) {
System.out.println("除数为0,出现了问题!!!!!!");
//System.exit(1);
//finally优先于return执行
//finally只有使用停止JVM的方法时才不执行
}finally {

System.out.println("关闭资源,finally语句被执行了..");

}
System.out.println("-------------------------end-------------------------");

}

}

/**
*
*/
package com.qfedu.Day15.Exception;

public class ExceptionDemo4 {

public static void main(String[] args) {
System.out.println(Result1());// 3
//System.out.println((int)(Math.random()*5));
System.out.println(Result2());
}
public static int Result1() {
int x = 9;
int y = 3;
int result = 0;
try {
result = x/y;
return result;

}catch(ArithmeticException e) {
return Integer.MAX_VALUE;
}finally {
result++;
System.out.println("result="+result);// 1 / 4
}

}
public static int Result2() {

try {

return 1 ;
}finally {

//语法:只有finally当中存在return语句,永远返回的是fianlly中的结果,要避免这样发生
return 100;
}
}

}

异常的分类:
所有异常的根类Throwable
知道其两个子类 Error 和 Exception
程序猿所处理的是Exception的异常
Error程序猿不处理 --> JVM所出现的错误

Exception --> 编译时异常
RuntimeException -->运行是异常

常见异常:
--------------------------------------------------------------------------------------------
NullPointerException 空指针异常 String str = null;
str.charAt() == null.charAt();
ArrayIndexOutOfBoundsException 数组下标越界异常 int[] array ={1,2};
array[100]
StringIndexOutOfBoundsException 字符串下标越界异常 String str ="ab";
str.charAt(10);
NumberFormatException 数据类型格式化异常 new Integer("11a");

ClassCastException 强制类型转换异常 一个父类对象在进行向下转型时
Animal a = new Dog();
Cat cat =(Cat)a
IOException 流异常 流使用错误

 

处理异常:

异常的特点:
若某行代码在执行过程中抛出异常,那么后面的代码就会不执行了(运行时和编译时都出现这个问题)
若需要据需执行或打印其他方式-->就需要处理掉当异常了

1.try...catch...finally
1.1try...catch
try是捕获异常 catch抓取出捕获的异常

try{
编译可能出现异常的代码
}catch(异常类型 e){ --->定义了一个异常类型的变量
//记录日志
//直接打印异常信息
//继续抛出异常
ps:无论在catch代码代码段中做任何事情,都是对异常的一种补救措施

/**
*
*/
package com.qfedu.Day15.Exception.ThrowAndThrows;

public class ThrowsDemo {
//后果:main已经是最终的位置,若在main中继续抛出异常,接受者只有一个JVM
//得到的结结果就是在控制台上打印跟中栈信息
//ps:throws主要的作用就是提示调用者有异常需要处理,一般会和编译时异常一起使用
public static void main(String[] args)throws NumberFormatException {

String str = "123a";

//正确的做法就是需要处理这个异常try...catch
//但是处理异常还有一种方法继续throws
int num = getResult(str);

}
public static int getResult(String value)throws NumberFormatException {
return new Integer(value);
}
}

/**
 * 
 */
package com.qfedu.Day15.Exception.ThrowAndThrows;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

import javax.management.RuntimeErrorException;

public class ThrowDemo {
    public static void main(String[] args)throws FileNotFoundException {
        //效果等同于return 
        //throw new RuntimeException();
        String str = "123a";
        try {
        int num = getNumber(str);
        }catch (NumberFormatException e) {
            System.out.println(e.getMessage());
        }    
        
        try {
            new FileInputStream("C:\test");
        } catch (FileNotFoundException e) {
            //1.7使用throw抛出一个异常对象,throw new 异常类型()
            //1.7之后增强语法catch中是不是已将获知异常类型而e是不是就是异常对象
            //throw可以直接在catch语句块中直接将异常对象抛出
            //ps:若这样使用就无法自定义信息了
            //throw new FileNotFoundException();
             throw e;
        }
//        int i = 0;
//        while(true) {
//            if(i == 200000) {
//                //最好不要
//               throw new RuntimeException("循环已经停止");
//            }
//            i++;
//            
//        }
        

    }
    public static int getNumber(String value) {
        try {
           return new Integer(value);
        }catch(NumberFormatException e) {
           throw new NumberFormatException("转换错误,你输入的是什么???");
        }
    }

    
}

 

}
总结:
1.若try语句块中出现异常,那么异常代码后的代码都不会执行,会直接跳转到catch语句块中执行
2.若try语句块中没有出现异常会继续执行,catch语句块将不会执行

catch语句块中处理异常的方法:
getMessage():捕获异常信息的描述,提示用户异常信息是什么
System.out.println(e.getMessage());
toString():捕获异常信息藐视以字符串的形式返回(不用)
System.out.println(e.toString());
printStackTrace()打印异常栈跟踪信息并输出到控制台上
ps:这个方法有一个重载,参数是输出流,指定输出的位置
基本上即使在处理日志--> 雷军 --> 人们最常问的的问题10个 --> Top N
一般来说我们都会在catch语句块中进行这个方法的调用并打印信息
主要用于:看到异常类型,异常原因,异常出现的位置,在开发调用和测试的过程中来进行使用
在完成项目进行提交时会做如下操:
1.改变输出作为日志存在
2.直接删除异常跟中信息,转而使用输出语句
看ExceptionDemo
若在执行代码中出现多个异常
多种类型异常处理:
try{
编写可能出现的代码异常
}catch(异常类型 e){
进行处理异常

}catch(异常类型 e){
进行异常处理

}....
//连级判断-->异常和异常之间有一定关联性 --> 反射的时候

//1.7新特性
看ExceptionDemo2

finally代码块
finally语句开表示最终的,无论如何都会执行(异常捕获是够成功与否)
finally语句块的作用:
通过try...catch的形式可以捕捉一些异常,某些时候例如:
我们在对一些物理资源(磁盘文件/网络连接/数据库连接),fianlly会进行资源释放和关闭操作
IO流中
捕获异常终极写法
try{
编译代码可能出现的异常
}catch(异常类型 e){ --> catch可以有多个
输出异常信息
}finally{ --> 只能有一个 在没有资源释放或关闭的情况下fianlly语句块可以省略
释放资源
}
看ExceptionDemo3
面试题:
看ExceptionDemo4
final , finally ,finalize 的区别

2.throw 和 throws
throw语法:
运用于方法的内部,抛出一个具体的异常对象
throw new 异常类型("异常信息"); -->等同于 return 可以让方法结束

throw作用:
当一个方法出现不正常的情况的时候,我们不知道该方法返回什么,此时就返回一个错误.
在catch语句块中继续向上抛出异常
return 是返回一个值 throw是返回一个错误,返回给该方法的调用者
throw创建一个异常对象并定义异常信息,用于传递给调用者
看ThrowDemo

throws语法:
定义于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常

设计当前throws抛出异常,在方法体中的所有异常你都不需要处理,在调用方法时必须处理当前抛出
的异常
throws使用需要谨慎,不要大批量随意抛出异常,只要处理时机不成熟的时候,才选择抛出

ps:
若是在main方法中抛出异常是完全可以的,但是在main方法中抛出异常会失去我们程序猿的作用!!
看ThrowsDemo

throw和throws的不同
throw:运用于方法内部,用于给调用者返回一个异常对象,和return一样会结束当前方法
throws运行于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
若throw创建的对象是编译时异常(Exception)那么在方法中需要使用throws或try...catch来处理
throws需要在定义在方法使用

自定义异常
系统中所提供的异常不能满足所有的需求时,此时我们可以定义自己异常
分两种:
1.当前异常是在程序运行时出现异常-->继承与RuntimeException
2.当前异常是在代码书写时就出现异常-->继承Exception

异常连和异常转换
异常转换:当位于最上层子系统不需要关系底层异常的细节时,常量的做法就是当前捕获的原有异常进行一个新
包装,使之成为一个全新的异常,然后在抛出
异常链:把原始的异常包装为新的一行,从而行程多个异常的存在,并且排列,有助于我们查找异常信息

数据结构:
数据结构是计算存储,组织数据的方式
编程 = 数据结构 + 算法
数据结构存在着多种关系,一对一 一对多 多对多 等等
常见的数据结构
数组,栈,链表,哈希表,队列,堆,树,图
java中集合框架其实就是数据结构的实现与封装
java中的集合根据使用不同的数据结构各种性能是不一样
最简单的就是数组 -->线性结构
ps:大话数据结构
需求:
模拟一个球员系统你是教练
1.初始容量为5的线性列表,准备用来存储场上的5个球员的号码
2.安排5个球员上场[11,22,33,44,55];
3.查询指定位置的球员的球衣号码是多好,查询索引2号码应该333
4.根据球衣号码查询该球员在场上的索引位置 44 ---> 3
5.替换场上所以位置为2的球员,替换之后该位置的球衣编号为333
6.替换球衣号码为22的球员 ,替换之后为222
7.把场上所以位置为2的球员罚下(即没有替补)
8按照球员在场上的位置打印球衣号码风格[11,22,33,44,55]
修改需求:
健壮性和安全性的修改
1.创建数组的时候 是不是可以传入一个负数
2.查找是会出现负数和大于数组长度的值
3.若我们需要添加元素,因为我们的大小是5个元素,扩充数组

Java就提供一个类是与我们封装的类的一种
集合:存储的是对象,不能存储值类型
集合是变长
集合提供了一些常用方法,让我们来进行增删改查等操作
List(列表):集合中的对象是按照索引位置存储的(有序),并且可以存储重复数据
Set(集):集合中的对象没有特定存储方法(无序-->无序不等于随机),并且不允许重复
Map(映射):集合中每一个元素都包含一对"键值对"key和value形式,不允许key重复,value可以重复

ArrayList集合:

/**
 * 
 */
package com.qfedu.Day15.ArrayList;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayListDemo {
        @SuppressWarnings("rawtypes") //注解
        public static void main(String[] args) {
            //1.无参
            ArrayList al = new ArrayList();
            //2.有参 --> 指定初始容量大小
            ArrayList al2 = new ArrayList(20);
            //3.通过构造方法在ArrayList集合当中存另外一个集合的元素
            ArrayList al3 = new ArrayList(al2);
            //常用方法:
            //向集合中添加元素
            al.add(1);
            al.add(2.1243);
            al.add("3");
            al.add(‘c‘);
            al.add("我可以存储任何数据类型");
            //因为ArrayList底层实现是数组,所以存在下标的概念
            //第一个元素的位置是0,最后一个元素的位置是size-1
            //集合可以直接打印对象-->重写了toString
            System.out.println(al);
            //向集合中添加指定元素
            al.add(1, "我是插入值");
            System.out.println(al);
            
            //向集合中插入另外一个集合
            al2.add("2018");
            al2.add(8);
            al2.add(17);
            //向集合中添加原有集合的值
            al.addAll(al2);
            System.out.println(al);
            //向指定位置添加集合
            //addAll(int index, Collection<? extends E> c) 
            
            //清空集合-->没有数据,集合还存在
            al2.clear();
            System.out.println(al2);
            
            //判断集合中是否存在指定元素
            //true 就是存在 false是不存在
            System.out.println(al.contains("2018"));

            //通过下标获取集合中的元素
            System.out.println(al.get(1));
            
            //判断集合中首次出现指定元素的位置
            //如果找到就返回其下标(第一次)
            //没有找到 -1
            System.out.println(al.indexOf("七夕"));
            
            //判断集合中是否存在元素(判断集合是不是空的)
            //true 空   false 有元素
            System.out.println(al.isEmpty());
            
            //返回集合中最后一次出现元素的位置
            //如果找到了返回值下标(最后一次)
            //返回-1
            System.out.println(al.lastIndexOf(17));
            
            //删除集合中的元素
            //根据下标删除指定位置的元素
            al.remove(1);
            System.out.println(al);
            
            //根据传入的指定元素删除
            //若集合中存在着两个相同的元素
            //删除第一次出现的,若集合中没有要删除的元素
            //得到一个返回值false --> 删除失败没有这个元素
            al.remove("2018");
            System.out.println(al);
            
            //传入指定位置替换指定的值
            al.set(0, "我是替换值");
            System.out.println(al);
            
            
            //将ArrayLis集合转换为数组,数组必须是Object
            Object[] array = al.toArray();
            System.out.println(Arrays.toString(array));
            //将数组转换为List集合
            List al4 = Arrays.asList(array);
            
            
        }
}