首页 > 编程语言 >0基础学java之Day18

0基础学java之Day18

时间:2024-10-31 17:19:12浏览次数:7  
标签:info java String Season 基础 枚举 Day18 public name

包装类

  • 理解:基本数据类型对应的类

  • 出现原因:

  • Java为纯面向对象语言,8种基本数据类型不能new对象,

  • 破坏了Java为纯面向对象语言的特征,所以Java有为8种

  • 基本数据类型分别匹配了对应的类,这种类叫做包装类/封装类

基本数据类型引用数据类型继承关系
byteByteObject.Number.Byte
shortShortObject.Number.Short
intIntegerObject.Number.Integer
longLongObject.Number.Long
floatFloatObject.Number.Float
doubleDoubleObject.Number.Double
charCharacterObject.Character
booleanBooleanObject.Boolean

注意:

  • int类型对应的包装类是Integer

  • char类型对应的包装类是Character

  • 其余的基本数据类型对应的包装类就是首字母大写

  • 应用场景:

    • 一个方法既可以接收整数也可以接收小数的参数,就可以把形参的类型设置为Number

    • 集合作为容器,需要设置元素的参数,元素参数必须是引用数据类型,如果想存储基本数据类型,就可以把元素类型设置为对应的包装类

public static void main(String[] args) {
    /*  double i=100.145;
        Double valueOf = Double.valueOf(i);
        System.out.println(valueOf);
        
    //手动拆箱  包装型->基本数据类型 
    Double double1 = new Double(120.365);
    double doubleValue = double1.doubleValue();
    System.out.println(doubleValue);*/
        
    
    //自动拆箱
    int i=200;
    Integer integer=i;
    System.out.println(integer);
    
    //自动拆箱
    Double double1 = new Double(365.365);
    double a=double1;
    System.out.println(a);
        
    //parseInt():将字符串转换为int值
    String str = "123";
    int num = Integer.parseInt(str);
    System.out.println(num+1);//124     
    }

Integer底层

//手写Integer方法创建MyInteger类
package com.qf.package_class;
​
public class MyInteger{
​
    private int value;
​
    public MyInteger(int value) {
        this.value = value;
    }
    
    public int intValue(){
        return value;
    }
    
    @Override
    public String toString() {
        return String.valueOf(value);
    }
    
    public static MyInteger valueOf(int i){
        if(i >= MyIntegerCache.low && i<= MyIntegerCache.high){
            return MyIntegerCache.cache[i - MyIntegerCache.low];
        }
        return new MyInteger(i);
    }
    
    //MyInteger缓存类 -- 存储了-128~127区间的MyInteger对象
    private static class MyIntegerCache{
        
        private static final int low = -128;
        private static final int high = 127;
        private static final MyInteger[] cache;
        
        static{
            cache = new MyInteger[high - low + 1];//创建数组共有256个元素(有0)
            int j = low//把最小值当作数组的第一个元素
            for (int i = 0; i < cache.length; i++) {
                cache[i] = new MyInteger(j);
                j++;
            }
        }
        
    }
}
//创建一个测试类
package com.qf.package_class;
​
public class Test03 {
    /**
     * 知识点:Integer的深入 -- 底层原理
     */
    public static void main(String[] args) {
        
//      Integer integer = new Integer(100);
//      int i = integer.intValue();
//      System.out.println(i);//100
//      System.out.println(integer);//100
        系统的Integer
        Integer integer1 = Integer.valueOf(100);
        Integer integer2 = Integer.valueOf(100);
        System.out.println(integer1 == integer2);//true
        
        Integer integer3 = Integer.valueOf(200);
        Integer integer4 = Integer.valueOf(200);
        System.out.println(integer3 == integer4);//false
        
        System.out.println("-------------------------------------");
        
//      MyInteger myInteger = new MyInteger(100);
//      int i = myInteger.intValue();
//      System.out.println(i);//100
//      System.out.println(myInteger);//100
        自己手写的MyInteger也能实现功能
        MyInteger myInteger1 = MyInteger.valueOf(100);
        MyInteger myInteger2 = MyInteger.valueOf(100);
        System.out.println(myInteger1 == myInteger2);//true
        
        MyInteger myInteger3 = MyInteger.valueOf(200);
        MyInteger myInteger4 = MyInteger.valueOf(200);
        System.out.println(myInteger3 == myInteger4);//false
    }
}
​

枚举

特点

  • 枚举就是一个受限制的类,默认继承Enum

  • 枚举的第一行必须定义该枚举类型的对象

  • 枚举类型对象默认添加: public static final 类型

  • 枚举没有继承明确类(自定义枚举类默认继承Enum,Enum默认继承Object)

  • 枚举类不能被继承

  • 枚举里可以有构造方法、成员方法、静态方法、抽象方法

  • 枚举可以实现接口

  • 枚举里没有定义方法,可以在最后一个对象后面加逗号、分号或什么都不加

优势

  • 增强代码可读性

  • 枚举型可直接与数据库交互

  • switch语句优势

  • 编译优势

    (枚举类编译时,没有把常量值编译到代码中,即使常量值发生改变,也不会影响引用常量的类 )

  • 将常量组织起来,统一管理

  • 去除equals两者判断 由于常量值地址唯一,使用枚举可以直接通过“==”进行两个值之间的对比,性能会有所提高

枚举的方法

方法名解释
Enum.valueOf(Class<E> enumType, String name)根据字符串找到该枚举类中的对象
public static void values()获取该枚举类对象数组
public static void valueOf(String args0)根据字符串获取该枚举类中的对象
public final String name()获取该枚举对象名字
public final Class<E> getDeclaringClass()获取枚举对象的枚举类型相对应的Class对象
public final int hashCode()获取该枚举对象的hash值
public final int compareTo(E o)两个枚举对象进行比较
public final boolean equals(Object other)比较两个枚举对象是否相同

需求:编写季节类(Season),该类只有四个对象(spring,summer,autumn,winter)

重点:只有四个对象 枚举的应用场景:一个类有固定的几个对象,就推荐使用枚举

枚举默认写了 public static final

//创建枚举
package com.qf.enum2;
​
public enum Season {  //注意这里是enum不是class类
    //底层实现:public static final Season spring = new Season("春天","春雨绵绵");
    spring("春天","春雨绵绵"),
    summer("夏天","烈日炎炎"),
    autumn("秋天","硕果累累"),
    winter("冬天","白雪皑皑");
//必须先创建枚举对象可以不写也可以逗号也可以分号结束
    
        private String name;
        private String info;
    
        private Season() {
        }
        private Season(String name, String info) {
            this.name = name;
            this.info = info;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getInfo() {
            return info;
        }
        public void setInfo(String info) {
            this.info = info;
        }
        
        @Override//重写toString方法
        public String toString() {
        
        return name+"   "+info;
        }
}
//创建一个测试类输出春夏秋冬及其他信息
public class Test01 {
    public static void main(String[] args) {    
        System.out.println(Season.spring);
        System.out.println(Season.summer);
        System.out.println(Season.autumn);
        System.out.println(Season.winter);
    }
}

枚举的底层

//还是刚才Season的代码反编译
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    
    private final String name;//枚举对象名
    private final int ordinal;//枚举对象编号(从0开始)
    
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
    
    public final String name() {
        return name;
    }
    
    public final int ordinal() {
        return ordinal;
    }
    
}
///
public final class Season extends Enum{
​
    public static final Season spring;
    public static final Season summer;
    public static final Season autumn;
    public static final Season winter;
    
    private String name;
    private String info;
    
    private static final Season[] ENUM$VALUES;//枚举数组
    
    static{
        //初始化该枚举类的四个对象,并且把枚举名和枚举编号一并记录下来
        spring = new Season("spring", 0, "春天", "春雨绵绵");
        summer = new Season("summer", 1, "夏天", "烈日炎炎");
        autumn = new Season("autumn", 2, "秋天", "硕果累累");
        winter = new Season("winter", 3, "冬天", "白雪皑皑");
        
        //初始化枚举数组
        ENUM$VALUES = new Season[]{spring, summer, autumn, winter};
    }
​
    //private Season(){}
    private Season(String s, int i){
        super(s, i);
    }
​
    //private Season(String name, String info){}
    private Season(String s, int i, String name, String info){
        super(s, i);
        this.name = name;
        this.info = info;
    }
​
    public String getName(){
        return name;
    }
​
    public void setName(String name){
        this.name = name;
    }
​
    public String getInfo(){
        return info;
    }
​
    public void setInfo(String info){
        this.info = info;
    }
​
    public String toString(){
        return (new StringBuilder(String.valueOf(name))).append(" -- ").append(info).toString();
    }
​
    //获取该枚举类所有的对象
    public static Season[] values(){
        Season[] aseason = ENUM$VALUES;
        int i = aseason.length;
        Season[] aseason1 = new Season[i];
        
        //参数 - 源数组,开始下标,目标数组,开始下标,拷贝长度
        System.arraycopy(aseason, 0, aseason1, 0, i);
        return aseason1;
    }
​
    public static Season valueOf(String s){
        return (Season)Enum.valueOf(com/qf/enum03/Season, s);
    }   
}
​
//测试类
package com.qf.enum03;
​
public class Test01 {
    /**
     * 知识点:枚举的方法
     */
    public static void main(String[] args) {
​
        //通过字符串获取对应枚举类里的对象
        Season season1 = Enum.valueOf(Season.class, "spring");
        
        //通过字符串获取对应枚举类里的对象
        Season season2 = Season.valueOf("spring");
        System.out.println(season1 == season2);//true
        
        //获取枚举对象名
        String name1 = season1.name();
        String name2 = season2.name();
        System.out.println(name1);
        System.out.println(name2);
        
        //获取枚举对象编号
        int ordinal1 = season1.ordinal();
        int ordinal2 = season2.ordinal();
        System.out.println(ordinal1);//0
        System.out.println(ordinal2);//0
        
        //获取该枚举类里所有的对象
        Season[] seasons = Season.values();
        for (Season season : seasons) {
            System.out.println(season);
        }
        
    }
    
}
​

标签:info,java,String,Season,基础,枚举,Day18,public,name
From: https://blog.csdn.net/2301_81594623/article/details/143372136

相关文章

  • Java——lambda表达式和StreamAPI
    一、lambda1. lambda表达式1.1Lambda表达式的使用举例:(o1,02)->Integer.compare(o1,o2);1.2Lambda表达式的格式举例:Lambda形参列表->lambda1.3Lambda表达式的格式lambda操作符或箭头操作符的左边:lambda形参列表,对应着要重写的接口中的抽象方法的形参列表。的右......
  • java8 map每10个分一组
    在Java8中,如果你想要将一个Map的条目每10个分为一组,你可以使用流(Streams)来实现这一功能。这里是一个例子,假设我们有一个Map<Integer,String>,我们想要将其每10个元素分为一组。首先,我们需要将Map的entrySet()转换为流,然后使用流的操作来实现分组。 importjava.util.......
  • JavaScript基础教程前言
     ---------------------------------------------------------------------有人22岁就毕业了,但等了五年才找到好的工作;有人25岁就当上CEO,却在50岁去世;也有人迟到50岁才当上CEO,然后活到90岁。 有人依然单身,同时也有人已婚。奥巴马55岁就退休,川普70岁才开始当总统。......
  • 记一次“网络安全扫描工具联动”自动化扫描漏洞流程,网络渗透必看基础教程!
    大家好,我是向阳假如你在一次攻防演练或者渗透测试中有多个攻击测试目标,一个一个去手动测试是肯定不现实的,可以先借助安全扫描工具去“自动扫描测试目标站点”的薄弱漏洞的位置,为你后续的深入测试提供事半功倍的效果。前言:随着当前网络安全威胁的不断扩展与升级,开展渗透测......
  • 【网络安全零基础入门】Linux安全加固(非常详细)零基础入门到精通,收藏这一篇就够了
    大家好,我是向阳。今天将继续带大家入门网络安全linux系统篇安全加固教程,全程干货,建议收藏哈安全加固方案原则1.版本升级对于系统和应用在使用过程中暴露的安全缺陷,系统或应用厂商会及时发布解决问题的升级补丁包。升级系统或应用版本,可有效解决旧版本存在的安全风险。......
  • 牛客网刷题(4)(Java之(static)静态变量、静态方法、静态代码块、静态内部类)
    目录一、static关键字。(1)牛客网题目。(2)总结。<1>静态变量。(类变量)1、特点。2、补充与注意。3、代码演示。<2>静态方法1、特点。2、补充与注意。3、代码演示。<3>静态代码块。1、特点。2、补充与注意。3、代码演示。<4>静态内部类。1、特点。2、注意事项。3......
  • java+vue计算机毕设冬季供热有限公司网站建设【开题+程序+论文+源码】
    本系统(程序+源码)带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着冬季气温的逐渐降低,供热服务成为了城市居民生活中不可或缺的一部分。冬季供热有限公司作为城市供热的主要提供者,承担着保障居民温暖过冬的重要职......
  • java+vue计算机毕设第二课堂学分认定系统【开题+程序+论文+源码】
    本系统(程序+源码)带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景在高等教育日益重视综合素质培养的今天,第二课堂作为第一课堂的有效补充,其在拓宽学生知识面、提升实践能力、增强综合素质等方面发挥着不可替代的作用......
  • React面试常见题目(基础-进阶)
    React面试常见题目及详细回答讲解基础题目(20个)什么是React?回答:React是一个用于构建用户界面的JavaScript库,它允许你将UI拆分成可复用的组件。React起源于Facebook的内部项目,用于构建高性能的Web应用界面。React组件有哪些类型?回答:React组件主要有函数组件和类组件两种类......
  • Java - 26 代码块
    Java-26代码块[修饰符static]{代码};类似于方法,没有方法名,没有返回,没有参数不用通过对象或类显式调用,而是在加载类或创建对象时隐式调用普通代码块好处构造器的补充机制(减少代码重复冗余),可以做初始化操作/*不管调用哪个构造器创建对象,都会先调用代码块的内......