第七章 面向对象基础---下（枚举）

最新推荐文章于 2024-07-09 16:17:35 发布
最新推荐文章于 2024-07-09 16:17:35 发布
阅读量1.9k 收藏 29
点赞数 22
分类专栏： Java 文章标签： java 开发语言 算法 intellij-idea 数据结构 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61150515/article/details/138087437
版权

1.枚举

1.1 概述

某些类型的对象是有限的几个，这样的例子举不胜举：

  • 月份：January(1月)......December(12月)

  • 季节：Spring(春节)......Winter(冬天)

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

        在JDK1.5之前，需要程序员自己通过特殊的方式来定义枚举类型。

        在JDK1.5之后，Java支持enum关键字来快速的定义枚举类型。

1.2 JDK 1.5 之前

在JDK1.5之前如何声明枚举类呢？

  • 构造器加private私有化

  • 本类内部创建一组常量对象，并添加public static修饰符，对外暴露这些常量对象

  • 枚举 ：列举 罗列

  • Java中,枚举它是一个特殊的类 ，这个有固定的几个有限的值，这个类的对象在声明类的时候就提前创建好了，后面不需要再创建 如何实现枚举？

  • JDK 1.5 之前

  • enum 列举,枚举 

示例代码：
/*
    季节：春天，夏天，秋天，冬天
*/
public class Enum {
    // 设置好的四个常量  全大写  把单词转为大写的快捷键  ctrl + shift + u
    public final static Enum SPRING = new Enum("春天");
    public final static Enum SUMMER = new Enum("夏天");
    public final static Enum AUTUMN = new Enum("秋天");
    public final static Enum WINTER = new Enum("冬天");

    public String description;

    // 无参构造
    public Enum() {
    }

    // 有参构造
    public Enum(String description) {
        this.description = description;
    }

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

    // set/get 方法
    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}
public class TeatEnum {
    public static void main(String[] args) {
        // 直接获取创建好的对象即可,不需要再 new
        Enum s1 = Enum.SPRING;
        Enum s2 = Enum.SUMMER;
        Enum s3 = Enum.AUTUMN;
        Enum s4 = Enum.WINTER;

        Enum s5 = Enum.SPRING;
        System.out.println(s1);// Season{description='春天'}
        System.out.println(s2);// Season{description='夏天'}
        System.out.println(s3);// Season{description='秋天'}
        System.out.println(s4);// Season{description='冬天'}
        System.out.println(s5);// Season{description='春天'}
        System.out.println(s1 == s5);// true
    }
}

1.3 JDK 1.5 之后

1、enum关键字声明枚举

【修饰符】 enum 枚举类名{
    常量对象列表
}

【修饰符】 enum 枚举类名{
    常量对象列表;
    
    其他成员列表;
}

public enum Week {
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY
}

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

2、枚举类的要求和特点

枚举类的要求和特点：

  1. 枚举类的常量对象列表必须在枚举类的首行，因为是常量，所以建议大写。

  2. 如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。

  3. 编译器给枚举类默认提供的是private的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数，

  4. 如果枚举类需要的是有参构造，需要手动定义，有参构造的private可以省略，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。

  5. 枚举类默认继承的是java.lang.Enum类，因此不能再继承其他的类型。

  6. JDK1.5之后switch，提供支持枚举类型，case后面可以写枚举常量名。

  7. 枚举类型如有其它属性，建议（不是必须）这些属性也声明为final的，因为常量对象在逻辑意义上应该不可变。

示例代码：
public enum Week {
    MONDAY("星期一"),
    TUESDAY("星期二"),
    WEDNESDAY("星期三"),
    THURSDAY("星期四"),
    FRIDAY("星期五"),
    SATURDAY("星期六"),
    SUNDAY("星期日");

    private final String description;

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

    @Override
    public String toString() {
        return super.toString() +":"+ description;
    }
}
public class TestWeek {
    public static void main(String[] args) {
        Week week = Week.MONDAY;
        System.out.println(week);

        switch (week){
            case MONDAY:
                System.out.println("怀念周末，困意很浓");break;
            case TUESDAY:
                System.out.println("进入学习状态");break;
            case WEDNESDAY:
                System.out.println("死撑");break;
            case THURSDAY:
                System.out.println("小放松");break;
            case FRIDAY:
                System.out.println("又信心满满");break;
            case SATURDAY:
                System.out.println("开始盼周末，无心学习");break;
            case SUNDAY:
                System.out.println("一觉到下午");break;
        }
    }
}

3、枚举类型常用的方法

  1. String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
  2. String name():返回的是常量名（对象名）
  3. int ordinal():返回常量的次序号，默认从0开始
  4. 枚举类型[] values():返回该枚举类的所有的常量对象，返回类型是当前枚举的数组类型，是一个静态方法
  5. 枚举类型 valueOf(String name)：根据枚举常量对象名称获取枚举对象
示例代码：
public enum Color {
    RED("红色", 1), GREEN("绿色", 2), BLUE, BLACK, YELLOW;

    Color() {

    }

    private String name;
    private int id;

    // 有参构造
    Color(String name, int id) {
        this.name = name;
        this.id = id;
    }
}
public class TestColor {
    public static void main(String[] args) {
        Color c1 = Color.RED;
        System.out.println(c1);// RED
        // 可以获取所有枚举的值
        Color[] cEnum = Color.values();
        for (Color value : cEnum) {
            // 常量名
            System.out.print(value.name() + "下标为:");
            // 下标
            System.out.println(value.ordinal());
        }
        /*结果：
        RED下标为:0
        GREEN下标为:1
        BLUE下标为:2
        BLACK下标为:3
        YELLOW下标为:4*/

        // 没有重写之前  拿到的是常量名
        System.out.println(Color.values()[1]);// GREEN
        // valueof(name)：根据常量名获取枚举对象

        Scanner scan = new Scanner(System.in);
        System.out.print("请输入你的操作：");
        String rel = scan.next();
        System.out.println(Color.valueOf(rel));
        scan.close();
    }
}

2.包装类

2.1 包装类

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

序号基本数据类型包装类（java.lang包）
1byteByte
2shortShort
3intInteger
4longLong
5floatFloat
6doubleDouble
7charCharacter
8booleanBoolean
9voidVoid

2.2 装箱与拆箱

装箱：把基本数据类型转为包装类对象。

转为包装类的对象，是为了使用专门为对象设计的API和特性

拆箱：把包装类对象拆为基本数据类型。

转为基本数据类型，一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等

装箱：基本数值---->包装对象

// 手动装箱
Integer objNum1 = new Integer(num3);
Integer objNum2 = Integer.valueOf(num3);

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

// 手动拆箱
Integer objNum2 = Integer.valueOf(num3);

int a = objNum2.intValue();

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

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

int m = 2;
 // 自动装箱
Integer objN = m;
// 自动拆箱
int k = objN;
/*
    注意点：
    自动装箱和拆箱存在对应的数据类型
*/

2.3 包装类的一些API

1、基本数据类型和字符串之间的转换

（1）把基本数据类型转为字符串
int a = 10;
//String str = a;//错误的
//方式一：
String str = a + "";
//方式二：
String str = String.valueOf(a);

（2）把字符串转为基本数据类型

String转换成对应的基本类型 ，除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型，例如：

  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。

  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。

  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

或把字符串转为包装类，然后可以自动拆箱为基本数据类型

  • public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类，然后可以自动拆箱为int基本类型

  • public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类，然后可以自动拆箱为long基本类型

  • public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类，然后可以自动拆箱为double基本类型

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");

int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");

2、数据类型的最大最小值

System.out.println("int 类型的最大值：" + Integer.MAX_VALUE);// 2147483647
System.out.println("int 类型的最小值：" + Integer.MIN_VALUE);// -2147483648

System.out.println("long类型的最大值：" + Long.MAX_VALUE);// 9223372036854775807
System.out.println("Long类型的最小值：" + Long.MIN_VALUE);// -9223372036854775808

3、字符大小写

Character.toUpperCase('a');
Character.toLowerCase('A');

4、整数转进制

// 转换进制的方法
System.out.println(Integer.toBinaryString(8));// 1000
// 八进制
System.out.println(Integer.toOctalString(20));// 24
// 十六进制
System.out.println(Integer.toHexString(20));// 14

5、比较的方法

// 比较大小
// 如果 A > B ，用正数表示 1
// 如果 A < B ，用负数表示-1
// 如果 A = B ，用 零 表示 0
double a = 100;
double b = 15;
System.out.println(Double.compare(a, b));// 1

2.4 包装类的特点

1.包装类缓存对象

包装类缓存对象
Byte-128~127
Short-128~127
Integer-128~127
Long-128~127
Float没有
Double没有
Character0~127
Booleantrue和false
int num1 = 1;
int num2 = 1;
System.out.println(num1 == num2);// true

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

// new 创建的包装类不是缓存，两个地址值，所以不相等
Integer objNum5 = new Integer(30);
Integer objNum6 = new Integer(30);
System.out.println(objNum5 == objNum6);// false

// 提供了相关比较的API
// valueOf：返回原始值 基本值
Integer objNum7 = Integer.valueOf(20);
Integer objNum8 = Integer.valueOf(20);
System.out.println(objNum7 == objNum8);// true

// 包装类型的 equals 重写了
System.out.println(objNum5.equals(objNum6));// true
System.out.println("-----------");
int m1 = 1;
// 包装类不可以变  无论是否使用缓存，包装类型一旦修改，就会产生一个新对象
// 如果频繁修改一个值，那么不建议使用包装类型，这样就会造成内存的浪费
Integer m2 = 1;
int[] arrM3 = {1};

addChange(m1, m2, arrM3);
System.out.println(m1);// 1
System.out.println(m2);// 1
System.out.println(arrM3[0]);// 2



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

2、类型转换

Integer i = 1000;
double j = 1000;
System.out.println(i==j);//true  会先将i自动拆箱为int，然后根据基本数据类型“自动类型转换”规则，转为double比较
Integer i = 1000;
int j = 1000;
System.out.println(i==j);//true 会自动拆箱，按照基本数据类型进行比较
Integer i = 1;
Double d = 1.0
System.out.println(i==d);//编译报错

3、包装类对象不可变

public class TestExam {
	public static void main(String[] args) {
		int i = 1;
		Integer j = new Integer(2);
		Circle c = new Circle();
		change(i,j,c);
		System.out.println("i = " + i);//1
		System.out.println("j = " + j);//2
		System.out.println("c.radius = " + c.radius);//10.0
	}
	
	/*
	 * 方法的参数传递机制：
	 * （1）基本数据类型：形参的修改完全不影响实参
	 * （2）引用数据类型：通过形参修改对象的属性值，会影响实参的属性值
	 * 这类Integer等包装类对象是“不可变”对象，即一旦修改，就是新对象，和实参就无关了
	 */
	public static void change(int a ,Integer b,Circle c ){
		a += 10;
//		b += 10;//等价于  b = new Integer(b+10);
		c.radius += 10;
		/*c = new Circle();
		c.radius+=10;*/
	}
}
class Circle{
	double radius;
}

3、抽象类

3.1 由来

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

        例如：当我们声明一个几何图形类：圆、矩形、三角形类等，发现这些类都有共同特征：求面积、求周长、获取图形详细信息。那么这些共同特征应该抽取到一个公共父类中。但是这些方法在父类中又无法给出具体的实现，而是应该交给子类各自具体实现。那么父类在声明这些方法时，就只有方法签名，没有方法体，我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类必须是抽象类。

3.2 语法格式

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

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

抽象类的语法格式

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

抽象方法的语法格式

【其他修饰符】 abstract 返回值类型 方法名(【形参列表】);

注意：抽象方法没有方法体

public abstract class Computer {
    public void computer() {

    }

    // 不需要方法体
    public abstract void calculate();

    public abstract void show();
}

public class PcComputer extends Computer {
    @Override
    public void calculate() {
        System.out.println("台式机计算");
    }

    @Override
    public void show() {
        System.out.println("台式机显示");
    }
}

public class TestAbstract {
    public static void main(String[] args) {
        Animals aa = new Animals("动物");
        aa.eat();
        // 是不可以直接对抽象类进行实例
        Computer co1 = new Book();
        Computer co2 = new PcComputer();

        co1.show();
        co2.show();
    }
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

3.3 注意事项

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

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

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

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

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

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

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

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

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

3.4 修饰符一起使用问题？

外部类成员变量代码块构造器方法局部变量内部类（后面讲）
public√√×√√×√
protected×√×√√×√
缺省√√×√√×√
private×√×√√×√
static×√√×√×√
final√√××√√√
abstract√×××√×√
native××××√××

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

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

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

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

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

static和final一起使用：

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

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

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

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

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

后续内容，正在更新...

戴眼镜的小胡
关注
  • 22
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 基础 第2阶段：面向对象编程-尚硅谷学习笔记（含面试题） 2023年
05-09
面向对象编程是Java的核心特性，本学习笔记涵盖了这一主题的深度探索，旨在帮助开发者深入理解并熟练运用面向对象的思想。2023年的版本更新可能包含最新的面试趋势和技术发展。以下将详细介绍Java面向对象编程的一些...
java基础第4章java-chapter4.rar
05-05
本章"java基础第4章java-chapter4.rar"深入探讨了Java的基础知识，帮助初学者巩固对这门语言的理解。以下是本章可能涵盖的一些关键知识点： 1. **类与对象**：在Java中，一切皆为对象。类是创建对象的模板，它定义...
java 抽象类
weixin_45713608的博客
09-12 82
抽象方法的语法格式。
枚举类的二三事
ikroal
09-26 171
枚举类
c语言编程季节输出春夏秋冬,c语言编程题: 用枚类型定义春、夏、秋、冬四个季节...
weixin_42395776的博客
05-26 1600
满意答案bcabcdefg2013.07.28采纳率：49%等级：12已帮助：5373人#includeenum season{spring = 1,summer,autumn,winter,};season GetSeasonByMonth(char month){if(month <= 3 && month>=1)return spring;else if(...
第7章 面向对象基础-下
weixin_53717489的博客
04-23 702
也可以通过”对象.静态方法“的方式调用（但是更推荐使用类名.静态方法的方式）。编译器会将如下两部分的。如果权限修饰符允许，在其他类中可以通过“类名.静态变量”直接访问，也可以通过“对象.静态变量”的方式访问（但是更推荐使用类名.静态变量的方式）。如果枚举类需要的是有参构造，需要手动定义，有参构造的private可以省略，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。编译器给枚举类默认提供的是private的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数，
第7章 面向对象基础-下（枚举，包装，抽象类）
qq_68079963的博客
04-22 989
某些类型的对象是有限的几个，这样的例子举不胜举：星期：Monday(星期一)......Sunday(星期天)性别：Man(男)、Woman(女)月份：January(1月)......December(12月)季节：Spring(春节)......Winter(冬天)支付方式：Cash（现金）、WeChatPay（微信）、Alipay(支付宝)、BankCard(银行卡)、CreditCard(信用卡)员工工作状态：Busy（忙）、Free（闲）、Vocation（休假）订单状态：Nonpayment（未
第一百二十七节 Java面向对象设计 - Java枚举方法
2301_78772942的博客
06-25 1238
第一百二十七节 Java面向对象设计 - Java枚举方法
第一百二十八节 Java面向对象设计 - Java枚举主体
2301_78772942的博客
06-25 709
Java面向对象设计 - Java枚举主体
软件工程 - 第8章 面向对象建模 - 2 静态建模
rc4gyyc的博客
12-01 4028
类图的核心组成类名，属性，操作关联（聚集、组合）、依赖、泛化、实现多样性（多重性）：通常在关联、聚合、组合中使用，代表有多少个关联对象存在。使用数字…星号（数字）表示实体类，如学生、商品，来自需求说明中的名词；控制类，如增加商品类、用户注册类；边界类，如对话框、窗体、菜单1.研究分析问题领域，确定系统的需求。2.发现对象与类，明确它们的含义和责任，确定属性和操作。3.发现类之间的关系。把类之间的关系用关联、泛化、聚集、组合、依赖等关系表达出来。4.设计类与关系。
面向对象-内部类-枚举-泛型-API
GemstonePhos的博客
02-26 98
面向对象-内部类-枚举-泛型-API
第二章 面向对象编程
05-21
面向对象编程是软件开发中的一种核心概念，尤其在JavaScript中，它允许我们通过类和对象来组织和处理数据。在本章中，我们将深入探讨JavaScript中的面向对象编程思想及其实践。 1. **JavaScript中的对象编程基础** ...
java第7章java-chapter7.rar
06-26
Java编程语言是面向对象的、跨平台的编程语言，它由Sun Microsystems（现已被Oracle公司收购）于1995年推出。Java以其简洁性、安全性、可移植性和高性能等特性，广泛应用于软件开发、移动应用、Web应用程序、企业级...
【05-面向对象(下)】
07-03
•如果采用匿名内部类语法来创建函数式接口的实例，只要实现一个抽象方法即可，在这种情况下即可采用 Lambda表达式来创建对象，该表达式创建出来的对象的目标类型就是这个函数式接口。 •Lambda表达式有如下两...
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1437
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
最新发布
servepeople的博客
07-09 1122
在 Java 中，可以通过多种方法将一个Object转换为Integer。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2123
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值