Java——Object

1.Object万类之祖

1.1 Object类型的概述

  • Object类是所有类型的顶层父类,所有类型的直接或者间接的父类;所有的类型中都含有Object类中的所有方法。

  • 随意定义一个类型,不手动显式定义其父类,那么这个类的父类就是Object类

  • public Object() {

    }

  • Object类的构造方法:Object()

    • 可以自己创建对象

    • 让子类访问,所有子类都会直接或者间接的访问到这个顶层父类的构造方法

    • Object类在执行构造方法时,不去访问自己的父类,因为没有父类了

1.2 getClass()

  • 返回当前对象的运行时类

    • 目前记住其中Class类型中有一个getName,可以返回当前类型的全类名
  • 示例

java 复制代码
public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.getClass().getName());
    }
}

1.3 hashCode()

  • 根据对象的情况,生成的一个整数,就是哈希码值。生成数字的方法就是hashCode方法,它是一个特征值。

  • 示例:

java 复制代码
public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.hashCode());

        demo = new Demo();
        System.out.println(demo.hashCode());
    }
}

1.4 toString方法

  • 返回当前对象的字符串表示

  • 对象返回一个地址值的字符串,没有什么意义

  • 最终操作:不需要手动重写,可以直接使用快捷键生成:Alt+Insert

  • 使用打印语句打印一个对象,其实打印的就是这个对象的toString内容

1.5 equals

  • 用于比较两个对象是否相等的方法,比较的就是"调用者"和"参数"这两个对象
  • boolean equals(Object obj)
  • 在Object类型中,是比较两个对象的地址值是否相同。
  • 实际生活中,比较两个对象的内存地址,没有什么意义。因此在自定义的子类中,都要重写这个方法。

    • 按照自定义的方式比较两个对象是否相同
  • 重写原则:

    • 一般比较两个对象中的所有属性,是否全部相同

    • <比如两个对象的name值相同,那么两个对象就相同>

  • 代码实例

java 复制代码
public class Simple01 {
    public static void main(String[] args) {
        Cat cat1 = new Cat("咪咪");
        Cat cat2 = new Cat("咪咪");
        boolean bool = cat1.equals(cat2);
        System.out.println(bool);
        // 表示获取全类名 包 +类名
        System.out.println(cat1.getClass());
    }
}

class Cat {
    private String name;

    public String getName() {
        return name;
    }

    public Cat(String name) {
        this.name = name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return this.getName().equals(cat.getName());
    }
}

1.6 ==和equals方法的区别

  • 相同点

    • ==和equals都是用于比较数据是否相等的方式
  • 不同点:

    • 比较内容的不同:

      • ==可以比较任意数据类型,既可以比较基本数据类型,也可以比较引用数据类型

      • equals方法只能比较引用数据类型

    • 比较规则不同:

      • ==在比较基本类型的时候,比较的是数据的值;比较引用类型时,比较的是地址值

      • equals方法在重写之前,比较的是两个对象的地址值;在重写之后,比较的属性值也就是类里面的属性值的大小。

2.内部类

2.1内部类的概述

  • 定义在内部的类,就是内部类。可以定义在类的内部,可以定义在方法的内部。

  • 根据定义的位置不同,可以分为:

  • 成员内部类

    • 普通的成员内部类

    • 私有的成员内部类

    • 静态的成员内部类

  • 局部内部类

  • 匿名内部类

2.2普通的成员内部类

  • 定义在成员位置上的类,就是成员内部类

  • 定义格式:

  • class 内部类类名 {

    内部类成员

    }

  • 成员内部类的说明:

    • 内部类可以直接访问外部类的所有成员,包括私有成员

    • 外部类访问内部类的成员,必须先创建内部类的对象

    • 在外部类以外,创建内部类的对象的格式:

      • 外部类名.内部类名 内部类对象名 = new 外部类名().new 内部类名();
  • 代码实例:

java 复制代码
/**
 * 普通成员内部类
 */
public class Simple02 {
    public static void main(String[] args) {
       
        Body.Heart heart = new Body().new Heart();
        heart.show();
    }
}

//类嵌套类\
class Body {
    private double height = 1.74;

    class Heart {
        int beats = 90;

        public void show() {
            System.out.println("身高是" + height + ",心跳每分钟" + beats);
        }
    }
	 
}

2.3私有的成员内部类

  • 也是一个成员内部类,在成员内部类前面加上一个private关键字

  • 访问方式说明:

    • 在外部类以外,不能直接访问外部类中的私有成员内部类

    • 可以在外部类中,定义一个访问私有内部类的公有方法,让外界可以调用公有方法,间接的访问外部类中的私有成员内部类。

  • 代码示例:

java 复制代码
public class Simple02 {
    public static void main(String[] args) {
        Body body = new Body();
        body.test();
    }
}

//类嵌套类\
class Body {
    private double height = 1.79;

    private class Heart {
        int beats = 90;

        public void show() {
            System.out.println("身高是" + height + ",心跳每分钟" + beats);
        }
    }
    public void test() {
        Heart hh = new Heart();
        hh.show();
    }
}

2.4 静态的成员内部类

  • 也是一个成员内部类,在成员内部类前面加上一个static关键字

  • 访问特点:

    • 静态内部类中的非静态成员,需要将所在的内部类对象创建出来之后,才能被调用。

    • 静态内部类中的静态成员,可以通过外部类名.内部类名的方式直接访问,而不需要创建外部类的对象

    • 总结:一个类是否需要创建对象,不取决于该类本身是否是静态,而取决于要访问的成员是否是静态

    • 静态成员内部类的对象创建格式:

    • 外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();

    • 代码实例

    java 复制代码
    public class Simple03 {
        public static void main(String[] args) {
            // 方式一:外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();
            Body2.Liver liver = new Body2.Liver();
            liver.show();
    
            // 方式二:外部类名.内部类名的方式直接访问
            System.out.println(Body2.Liver.FUNC);
    
        }
    
    }
    
    class Body2 {
        private double weight = 180;
    
        static class Liver {
            String color = "black";
            static final String FUNC = "解毒";
    
            void show() {
                System.out.println("肝都变成" + color + "色了,少整点吧!");
            }
        }
    }

2.5局部内部类

  • 定义在方法中的内部类

  • 说明:

    • 问题:属于方法中的局部变量,外界都没有办法访问到

    • 解决方式:在方法内部定义调用方式

    • 代码示例:

    java 复制代码
    public class Simple3 {
            public static void main(String[] args) {
                    new Body2().methodTest();
            }
        }
        
        class Body2 {
            void methodTest () {
                class SeaFood {
                    void eat () {
                        System.out.println("喝酒不能吃海鲜");
                    }
        
                }
                new SeaFood().eat();
            }
        
    }

2.6 匿名内部类【常用】

  • 没有名字的内部类

  • 匿名内部类的使用前提:

    • 匿名类:继承一个类

    • 匿名类:实现一个接口

  • 格式:

  • new 父类类名或者接口名() {

    父类方法的重写或者是接口内容的实现

    }

  • 本质:创建了一个类的子类对象、接口的实现类对象

  • 示例代码

java 复制代码
public class Simple04 {
    public static void main(String[] args) {
        // 父 new 子
        Games games = new MyGames();
        games.play("LOL");
        // 匿名内部类
        new Games() {
            @Override
            public void play(String name) {
                System.out.println("会玩" + name);
            }
        }.play("王者荣耀");

        // 拉姆达表达式
        Games games1 = (name) -> System.out.println("会玩" + name);
        games1.play("三国杀");

    }
}

interface Games {
    void play(String name);
}

class MyGames implements Games {
    @Override
    public void play(String name) {
        System.out.println("会玩" + name);
    }
}

3.String

3.1概述

  • String就是字符串类型,属于java.lang包,不需要导包

  • 所有的字符串常量"Hello World","abc"都属于String类型的对象

  • 字符串字面值属于常量,存储在方法区的常量池中。

  • String类型是一个常量,在创建之后就无法更改(是一个不可变的字符序列)。

  • 不可变的原因是String类型只提供了构造方法,没有提供set方法,因此只能在创建对象的时候,初始化成员变量,将来对象创建完成之后,无法通过方法来修改。

  • 代码示例:

java 复制代码
public class Simple05 {
    public static void main(String[] args) {
        String str2 = "abc";
        System.out.println(str2);//abc
        str2 = "xyz";
        System.out.println(str2);//xyz
    }
}

3.2 String类型的构造方法

  • String():创建一个空字符串

  • String(String original):创建参数字符串的一个副本(字符串是在常量池中,构造方法创建的字符串是在堆内存中)

  • String(byte[] arr):将一个字节数组转成一个字符串,将我们不认识的字节数组,转成了我们认识的字符串,过程叫做【解码】查询的是当前平台默认的编码表

  • String(byte[] arr, int offset, int length):将字节数组的一部分转成字符串

  • String(char[] arr):将字符数组转成字符串

    • 既不是编码,也不是解码,只不过是把字符串成了串
  • String(char[] arr, int offset, int length):将字符数组的一部分转成字符串

  • 代码示例:

java 复制代码
public class Simple06 {

    public static void main(String[] args) {
        //test1_空参构造();
        //test2_原始字符串转换();
        //test3_字节数组转字符串();
        test4_字符数组转成字符串();
    }

    private static void test4_字符数组转成字符串() {
        char[] arr = {'a', 'b', 'X', 'Y'};
        String str1 = new String(arr);
        System.out.println(str1);//abXY  只是组成字符串而已

        //将字符 数组的一部分转成字符串,
        String str2 = new String(arr, 1, 2);
        System.out.println(str2);//bX
    }

    private static void test3_字节数组转字符串() {
       //将整个字节数组转成了字符串
        byte[] bytes = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};
        String s = new String(bytes);
        System.out.println(s);
      
        /*将字节数组的一部分转成字符串,
         * 其中offset是从哪个索引开始,length表示要将多少个字节是转成字符串
         */
        byte[] arr = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};
        String str2 = new String(arr, 1, 4);
        System.out.println(str2);
    }

    private static void test2_原始字符串转换() {
        String str = new String("abc");//这个对象,在堆内存中
        //"abc"常量,在方法区的常量池
        //new String("abc")这个对象,在堆内存中
        //str指向了堆内存中的对象
        System.out.println(str);//abc
        System.out.println(str == "abc");//false
        System.out.println("abc" == "abc");//true
    }

    public static void test1_空参构造() {
        String str = new String();
        System.out.println(str);
    }
}

3.3 String类型的判断功能

  • equals(Object obj):判断调用者和参数对象描述的字符串内容是否相同

  • equalsIgnoreCase(String otherStr):忽略大小写判断两个字符串内容是否相同

  • contains(String str):判断调用者是否包含了str这个子串

  • startsWith(String prefix):判断调用者是否以prefix开头

  • endsWith(String suffix):判断调用者是否以suffix结尾

  • isEmpty():判断调用者是否是空串

  • 代码示例

java 复制代码
public class Simple07 {

    public static void main(String[] args) {
//        test1_equals();
//        test2_equalsIgnoreCase();
//        test3_包含();
//        test4_5_判断开始和结束();
//        test6_判断为空();
    }
    private static void test6_判断为空() {
        String str = "abc";
        System.out.println(str.isEmpty());//false  字符串不为null
    }

    private static void test4_5_判断开始和结束() {
        String str = "abcdefg";
        System.out.println(str.startsWith("abc"));//true
        System.out.println(str.startsWith("abd"));//fasle
        System.out.println(str.startsWith("cde"));//false
        System.out.println(str.endsWith("efg"));//true
    }

    private static void test3_包含() {
        String str1 = "abcdefg";
        System.out.println(str1.contains("abc"));//true
        System.out.println(str1.contains("efg"));//true
        System.out.println(str1.contains("cde"));//true
        System.out.println(str1.contains("ace"));//false 必须是连续的
    }

    private static void test2_equalsIgnoreCase() {
        String str1 = "abcDEF";
        String str2 = "abcdef";
        System.out.println(str1.equals(str2));//false 字符串不相等
        //忽略大小写判断两个字符串内容是否相同
        System.out.println(str1.equalsIgnoreCase(str2));//true
    }

    private static void test1_equals() {
        String str1 = new String("abc");//在堆中
        String str2 = new String("abc");
        System.out.println(str1 == str2);//false 两个对象地址不一样 new了两次
        System.out.println(str1.equals(str2));//true  指向同一个对象
    }
}

3.4 String类型的获取功能

  • length():获取字符串字符的个数

  • charAt(index):返回调用者字符串中索引为index的字符(和length方法结合之后可以遍历字符串)

  • substring(int beginIndex):获取一个字符串,内容是从当前字符串的beginIndex索引开始,一直到最后一个字符机截止

  • substring(int beginIndex, int endIndex):获取一个指定索引范围的子串

    • 注意事项:1、包含头不包含尾,返回的结果中,不包含endIndex索引指向的字符;2、所有的方法都无法修改字符串对象本身,一般都是返回一个新的字符串对象
  • indexOf家族:

    • indexOf(int ch):返回ch字符在当前调用者字符串中,第一次出现的索引

    • indexOf(int ch, int fromIndex):从fromIndex索引开始寻找,找到ch字符在当前字符串中第一次出现的索引

    • indexOf(String str):返回的是str这个字符串在调用者字符串中第一次出现的索引

    • indexOf(String str, int fromIndex):从fromIndex索引开始寻找,找到str字符串在当前字符串中第一次出现的索引(注意:无论从哪个位置开始找,所有字符的索引都不会变化)

  • lastIndexOf家族:

    • 和IndexOf基本一样,只不过是从后往前找,所有字符和字符串的索引也都不会发生变化
  • 示例代码

java 复制代码
public class Simple08 {

    public static void main(String[] args) {
        test1_length();
        test2_charAt();
        test3_字符串遍历();
        test4_获取子串();
        test5_indexOf();
        test6_lastIndexOf();
    }
    private static void test6_lastIndexOf() {
        String str = "abcdabcd";
        System.out.println(str.lastIndexOf('c'));
        System.out.println(str.lastIndexOf('c', 5));

        System.out.println(str.lastIndexOf("cd"));
        System.out.println(str.lastIndexOf("cd", 5));
    }

    private static void test5_indexOf() {
        String str = "abcdabcd";
        //返回第一个c出现的索引
        System.out.println(str.indexOf('c'));
        System.out.println(str.indexOf('c', 3));

        System.out.println(str.indexOf("cd"));//2
        System.out.println(str.indexOf("cd", 3));
    }

    private static void test4_获取子串() {
        String str = "abcdefg";
        String result = str.substring(3);
        //str本身不会变化,因为字符串对象是一个不可变的字符序列
        System.out.println(str);
        //substring可以返回一个新的字符串对象
        System.out.println(result);
        //通过两个参数的substring获取子串
        System.out.println(str.substring(2, 5));
    }

    private static void test3_字符串遍历() {
        String str = "abcdefg";
        //遍历字符串
        for (int i = 0; i < str.length(); i++) {
            System.out.println(str.charAt(i));
        }
    }

    private static void test2_charAt() {
        String str = "abcdefg";
        char c = str.charAt(3);
        System.out.println(c);
    }

    private static void test1_length() {
        String str = "abcdefg";
        System.out.println(str.length());
    }
}

3.5 String类型的转换功能

  • byte[] getBytes():将当前字符串,转成字节数组(编码)

  • char[] toCharArray():将当前的字符串,转成字符数组

  • toUpperCase():将当前的字符串,转成全大写形式

  • toLowerCase():将当前的字符串,转成全小写形式

  • concat(String str):将当前调用者,和参数str进行拼接,返回拼接后的长字符串(不常用,因为更多使用的是运算符+)

  • valueOf家族:可以将任意数据类型的数据,转换成字符串 (静态方法)

  • 代码示例:

java 复制代码
public class Simple09 {
    public static void main(String[] args) {
        test1_getBytes();
        test2_toCharArray();
        test3_upperAndLower();
        test4_concat();
        test5_valueOf();
    }

    private static void test5_valueOf(){
        //可以将任意数据类型的数据,转换成字符串
        System.out.println(String.valueOf(false));
        System.out.println(String.valueOf('x'));
        System.out.println(String.valueOf(new char[] {'a', 'b'}));
        System.out.println(String.valueOf(100));
        Object obj = null;
        System.out.println(String.valueOf(obj));
    }

    private static void test4_concat() {
        String str = "abc";
        String result = str.concat("xyz");
        System.out.println(result);
        System.out.println(str + "xyz");
        //将当前调用者,和参数str进行拼接,返回拼接后的长字符串(不常用,因为更多使用的是运算符+)
    }

    private static void test3_upperAndLower() {
        String str = "aBCdEfG";
        String upper = str.toUpperCase();//:将当前的字符串,转成全大写形式
        System.out.println(str);
        System.out.println(upper);
        String lower = str.toLowerCase();//:将当前的字符串,转成全小写形式
        System.out.println(lower);
    }

    private static void test2_toCharArray() {
        String str = "abcdefg";
        char[] arr = str.toCharArray();//将当前的字符串,转成字符数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

    }

    private static void test1_getBytes() {
        String str = "abc";
        byte[] arr = str.getBytes();//将当前字符串,转成字节数组(编码)
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

3.6 String类型的其他方法

  • replace(String oldStr, String newStr):将调用者中的老串替换成新串

  • trim():去掉字符串左右两边的空格、制表符

  • split:

    • split(String regex, int limit):字符串按照某个字符串进行分割,返回字符串数组,且限制返回元素个数。

    • split():不限制返回元素个数。

    • String str = "Hello,World!com.coding-future";

      String[] s = str.split("[,!.-]");

      System.out.println(Arrays.toString(s));

      }

    • format

    • String str = String.format("我是%s人,我爱%s","中国","中国");

    • 代码示例

    java 复制代码
    public class Simple10 {
        public static void main(String[] args) {
            test2_trim();
            test1_replace();
        }
    
        //去掉字符串左右两边的空格、制表符
        private static void test2_trim() {
            String str = "  I love java,  java is good ";
            String result = str.trim();
            System.out.println(str);
            System.out.println(result);
        }
    
        //将调用者中的老串替换成新串
        private static void test1_replace() {
            String str = "I love java, java is good";
            String result = str.replace("java", "study");
            System.out.println(str);
            System.out.println(result);
        }
    }

4. StringBuffer && StringBuilder

4.1概述

  • 内存理解:

java 复制代码
public class Simple11 {
    public static void main(String[] args) {
        String[] strArr = {"java", "javascript", "html", "css", "nodejs"};
        String s1 = "我会的技能有:";
        for (String s : strArr) {
            s1 += s;
            s1 += ",";
        }
        System.out.println(s1);
    }
}
  • StringBuilder是一个可变的字符序列,因为在类中提供了修改私有成员变量的方法

    • 常用的方法是append和insert,就是在StringBuilder对象本身上,进行修改操作
  • String类型和StringBuilder的关系:都是用于描述字符串

    • String是不可变的字符序列,没有提供修改私有成员的方法;StringBuilder是可变的字符序列,因为提供了修改成员变量的方法;

    • String长度本身也不可以变化,StringBuilder长度可以变化,可以认为StringBuilder就像一个可以伸缩的容器,用于存储字符

4.2构造方法

  • 构造方法作用:创建当前对象、将其他类型的数据,转换成当前类型

  • StringBuilder的构造方法:

    • StringBuilder():创建一个生成器,初始容量为16个字符

    • StringBuilder(int capacity):创建一个生成器,初始容量为capacity大小

    • StringBuilder(String str):创建一个生成器,初始值就是str这些字符,初始大小是str+16

  • 获取容积的方法:

    • capacity():获取当前生成器的容器大小

    • length():获取当前生成器中的字符个数

  • 代码示例

java 复制代码
public class Simple12 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1.capacity());//16

        StringBuilder sb2 = new StringBuilder(10);
        System.out.println(sb2.capacity());//10

        StringBuilder sb3 = new StringBuilder("Hello");
        System.out.println(sb3.capacity());//21
        System.out.println(sb3.length());//字符个数是5
    }
}

4.3添加功能

  • append(任意类型):可以将任意数据类型,转成字符,添加到生成器中

  • insert(int index, 任意数据类型):可以将任意数据类型,添加到指定的位置

    • index的范围是0~当前缓冲区的大小

    • 插入数据之后,数据本身的索引就是参数中指定的index

  • 实例代码

java 复制代码
private static void test1insert() {
        StringBuilder sb1 = new StringBuilder();//"1"
        sb1.insert(0, "a");
        System.out.println(sb1);//1
        sb1.insert(0, "b");
        System.out.println(sb1);//ba
        sb1.insert(1, "xyz");
        System.out.println(sb1);//bxyza
   }

4.4删除功能

  • deleteCharAt(int index) :删除指定索引的字符

  • delete(int start, int end):删除指定范围的字符,被删除的部分包含头不包含尾

  • 实例代码

java 复制代码
public class Simple13 {
    public static void main(String[] args) {
        //test1_deleteCharAt();
        test2_delete();
    }

    private static void test2_delete() {
        StringBuilder sb1 = new StringBuilder("abcdef");
        //删除cd
        sb1.delete(2, 4);
        System.out.println(sb1);//abef
    }

    private static void test1_deleteCharAt() {
        StringBuilder sb1 = new StringBuilder("abcdefg");
        sb1.deleteCharAt(2);
        System.out.println(sb1);//abdefg  删除指定索引的字符
        sb1.deleteCharAt(6);//String索引越界异常
        System.out.println(sb1);
    }
}

4.5替换和反转功能

  • replace(int start, int end ,String str):

    • 将字符串缓冲区中的从start开始到end-1这部分内容,替换成str
  • reverse():将原有字符序列进行反转

  • 示例代码

java 复制代码
public class Simple14 {
    public static void main(String[] args) {
        test1_replace();
        test2_reverse();
    }

    private static void test2_reverse() {
        StringBuilder sb1 = new StringBuilder("abcdefg");
        sb1.reverse();
        System.out.println(sb1);
    }

    private static void test1_replace() {
        StringBuilder sb1 = new StringBuilder("abcdefg");
        sb1.replace(2, 5, "qq");
        System.out.println(sb1);
    }
}

4.6.StringBuffer和StringBuilder的区别

  • 共同点:

    • 都是字符串的缓冲区,都是字符串的生成器,都是可变的字符序列
  • 不同点:

    • 出现版本不同:

      • StringBuffer在jdk1.0出现的

      • StringBuilder在jdk1.5出现的

    • 线程安全性不同:

      • StringBuffer是线程安全的,在多线程环境下仍然保证数据安全

      • StringBuilder是线程不安全,在多线程环境下无法保证数据安全

    • 效率不同:

      • StringBuffer效率低

      • StringBuilder效率高

5.包装类

5.1概述

java 复制代码
class Test {
    String str = "50";
    int a = (int) str; //此方式是否可以将str转成int类型
    int age = null; // 是否可以这样操作?
}
  • 基本数据类型有八种,都是非常简单的数据类型

  • 在这些类型中,只能表示简单的数据,不能包含一些操作数据的方法,没有办法存储描述这些数据的内容。需要准备一个引用数据类型,能将基本数据类型进行包装,提供一些操作基本类型的方法,定义一些描述数据的数据。

  • 基本类型的包装类:

    byte Byte
    short Short
    int Integer类型
    long Long
    float Float
    double Double
    char Character
    boolean Boolean
  • 各种包装类型的方法、特点基本相同,只要学习一个Integer类型,其他的也触类旁通。

  • Integer类型的对象中,维护了一个私有的成员变量,是一个int类型的字段(成员变量、属性),用于表示这个Integer对象要表示的数字。

  • 提供了在int、Integer、String类型之间相互转换的方法

5.2 Integer的构造方法

  • Integer(int i):将一个基本类型的int数,转换成Integer类型的对象使用i给Integer对象中的成员变量赋值

  • Integer(String s):将一个字符串类型的数字,转换成Integer类型的对象转换的作用

  • 示例代码

java 复制代码
public class Simple15 {
    public static void main(String[] args) {
        //将一个基本类型的int数,转换成Integer类型的对象使用i给Integer对象中的成员变量赋值
        Integer it = new Integer(100);
        System.out.println(it);

        //将一个字符串类型的数字,转换成Integer类型的对象转换的作用
        Integer it1 = new Integer("100");
        System.out.println(it1 + 10);
    }
}

5.3 Integer、int、String类型互相转换的总结

  • Integer转换成int类型

    • intValue()
  • int转换成Integer类型

    • 构造方法Integer(int i)
  • Integer到String的转换

    • toString方法即可
  • String到Integer的转换

    • Integer.valueOf(String str)
  • int转换成String类型:

    • Integer.toString(int i)
  • String转换成int类型

    • Integer.parseInt(String str)

    java 复制代码
    public class Simple16 {
        public static void main(String[] args) {
        
            Integer it2 = 10;
            int i = it2.intValue(); // i 没有操作方法
            Integer it3 = new Integer(20);
    
            System.out.println(it3);// it3有操作方法
    
            String s = it3.toString();
            System.out.println(s);// 字符串
    
            Integer it4 = Integer.valueOf(s);
            System.out.println(it4); // Integer
    
            String s1 = Integer.toString(i);
            System.out.println(s1);// 字符串
    
            int i1 = Integer.parseInt(s1);
            System.out.println(i1);// int 类型
    
        }
    }

5.4 自动装箱和拆箱

  • 装箱和拆箱:

    • 装箱:将基本数据类型,封装成包装类型的对象(引用类型),这个过程就是装箱,使用构造方法即可

    • 拆箱:从包装类型的对象中,将其包装的基本类型的数据取出,这个过程就是拆箱,使用intValue方法即可

  • 自动装箱和拆箱

    • 自动装箱:可以直接使用基本类型的数据,给引用类型的变量赋值

    • 自动拆箱:可以直接使用包装类对象,给基本类型的变量赋值:包装类对象直接进行算数运算

  • 示例代码

java 复制代码
public class Simple17 {
    public static void main(String[] args) {
        Integer it = 100;//自动装箱,100基本数据类型给integer包装类型赋值
        int i = it;//自动拆箱,

        System.out.println(it + 1);//自动拆箱  变成基本类型 然后运算

        Integer inte = 100; // 先装箱
        inte = inte + 1;//先自动拆箱,计算,最后自动装箱
    }

    private static void test1_装箱和拆箱() {
        int i = 100;
        Integer it = new Integer(i);//装箱

        int j = it.intValue();//拆箱
    }
}

6. 包(package)

  • 包:用于分类存放类文件(.class)的文件夹,在out/production目录下存放.class

  • 作用:

    • 包帮助管理大型软件系统:将功能相近的类划分到同一个包中。比如:MVC的设计模式

    • 包可以包含类和子包,划分项目层次,便于管理

    • 使用package声明类或接口所属的包,声明在源文件的首行

    • 解决类命名冲突的问题,同一个包下,不能命名相同的类和接口,不同的包下,可以命名同名的类和接口。

    • 每"."一次,就代表一层文件目录。

  • 命名:域名倒着写:com.xxxx.www(全球唯一)

  • 包的声明:使用package的关键字,声明当前的类是属于指定的包的。

  • 效果:

    • 编译的这个类,就会进入到一个指定的文件夹中。

    • 当前的类,名称也发生了变化,类名变成了【包名 + 类名】

  • 简化:

    每次使用其他包的类的时候,都需要写很长一串全类名,所以非常麻烦,需要简化. 使用import语句进行简化,在类的声明上,写一个import语句,将这个类的全类名导入进来,在该类中,就可以直接使用这个类的简写形式了。

  • 注意事项:

    • 在源文件中使用import显式的导入指定包下的类或接口

    • 声明在包的声明和类的声明之间。

    • 如果导入的类或接口是java.lang包下的,或者是当前包下的,则可以省略此import语句。 System, String...

    • 如果需要导入多个类或接口,那么就并列显式多个import语句即可

    • 可以使用java.util.*的方式,一次性导入util包下所有的类或接口,不建议使用import *,使用import到类名。

相关推荐
新手小袁_J4 分钟前
JDK11下载安装和配置超详细过程
java·spring cloud·jdk·maven·mybatis·jdk11
呆呆小雅5 分钟前
C#关键字volatile
java·redis·c#
Monly215 分钟前
Java(若依):修改Tomcat的版本
java·开发语言·tomcat
boligongzhu6 分钟前
DALSA工业相机SDK二次开发(图像采集及保存)C#版
开发语言·c#·dalsa
Eric.Lee20216 分钟前
moviepy将图片序列制作成视频并加载字幕 - python 实现
开发语言·python·音视频·moviepy·字幕视频合成·图像制作为视频
Ttang238 分钟前
Tomcat原理(6)——tomcat完整实现
java·tomcat
7yewh9 分钟前
嵌入式Linux QT+OpenCV基于人脸识别的考勤系统 项目
linux·开发语言·arm开发·驱动开发·qt·opencv·嵌入式linux
钱多多_qdd18 分钟前
spring cache源码解析(四)——从@EnableCaching开始来阅读源码
java·spring boot·spring
waicsdn_haha20 分钟前
Java/JDK下载、安装及环境配置超详细教程【Windows10、macOS和Linux图文详解】
java·运维·服务器·开发语言·windows·后端·jdk
_WndProc22 分钟前
C++ 日志输出
开发语言·c++·算法