day_17 内部类，常用API类

最新推荐文章于 2024-03-28 18:22:59 发布

十点半吃糖

最新推荐文章于 2024-03-28 18:22:59 发布

阅读量72

点赞数

分类专栏： JavaSE基础

本文链接：https://blog.csdn.net/weixin_44996823/article/details/111508675

版权

JavaSE基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

内部类

在类的内部，创建一个类，这个类就是内部类，包含内部类的类称为外部类

内部类分类成员内部类和局部内部类

成员内部类

public class OuterClass {
    private int num =10;
    private int num1 = 20;
    //成员内部类
    public class InnerClass{
        private double a = 100.1;
        public  void print(){
            System.out.println(num +"---"+num1);
            show();
        }
    }

    public  void show(){
        System.out.println(num +"---"+num1);
    }

    public static void main(String[] args) {
        OuterClass oc = new OuterClass();
        System.out.println(oc.num);
        System.out.println(oc.num1);
        oc.show();
        // 调用内部类的成员方法、成员属性
        //1 需要创建内部类的对象 需要通过 外部类 的对象来创建内部类的对象  创建出来的对象是内部类类型
        InnerClass innerClass = new OuterClass().new InnerClass();
        System.out.println(innerClass.a);
        innerClass.print();
    }
}

包含有成员内部类的类编译之后会产生几个class文件？
在这里插入图片描述
在成员内部类中不能存在static修饰的成员

如果在内部类中使用this此时的this代表的是内部类的当前对象

package cn.lanqiao.inner;

public class OuterClass {
    private int num =10;
    private int num1 = 20;
    //成员内部类
    private class InnerClass{
        private double a = 100.1;
         int i = 100;
         public  InnerClass(){

         }
         public InnerClass(int i){
             this.i = i;
         }
        public  void print(){
            System.out.println(num +"---"+num1);
            show();
        }
    }

    public  void show(){
        System.out.println(num +"---"+num1);
    }

    public static void main(String[] args) {
        OuterClass oc = new OuterClass();
        System.out.println(oc.num);
        System.out.println(oc.num1);
        oc.show();
        // 调用内部类的成员方法、成员属性
        //1 需要创建内部类的对象 需要通过 外部类 的对象来创建内部类的对象  创建出来的对象是内部类类型
        InnerClass innerClass = new OuterClass().new InnerClass();
        // 使用外部类已有的对象来创建外部类  同时可以使用他的重载的 构造方法
        InnerClass innerClass1 =oc.new InnerClass(100);
        System.out.println(innerClass.a);
        innerClass.print();
    }
}

局部内部类

package cn.lanqiao.inner;

public class OuterClass {
    private int num =10;
    private int num1 = 20;

    public  void show(){
        System.out.println(num +"---"+num1);
        // 局部内部类    相当于方法的一个局部变量 局部变量不能使用访问修饰符
         class  InnerClass{
            private  int i = 100;
            public void  print(){
                System.out.println(num +"--"+ num1+"--"+i);
            }
        }
        // 局部内部类的 声明周期和局部变量相同 仅限于当前方法中来使用  在方法的 外部是访问不到的
        //在方法中如果要访问局部内部类的成员  则需要创建局部内部类的 对象来访问
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.i);
    }

    public static void main(String[] args) {
        OuterClass oc = new OuterClass();
        oc.show();

    }
}

编译后也是两个Class文件
在这里插入图片描述

匿名内部类

public interface InterDemo{
	void method();
}

public class ClassDemo {
    public  void  show(InterDemo interDemo){
        interDemo.method();
    }

    public static void main(String[] args) {
        ClassDemo demo = new ClassDemo();
        demo.show(new InterDemo() {
            @Override
            public void method() {
                System.out.println("这是使用匿名内部类来实现接口的");
            }
        });
    }
}

常用API类

1.Math类

1、Math类概述

Math 包含执行基本数字运算的方法

2、Math中方法的调用方式

Math类中无构造方法，但内部的方法都是静态的，则可以通过类名.进行调用

3、Math类的常用方法

在这里插入图片描述

2.Random类

Math 类中虽然为我们提供了产生随机数的方法 Math.random()，但是通常我们需要的随机数范围并不是[0, 1)之间的 double 类型的数据，这就需要对其进行一些复杂的运算。如果使用 Math.random()计算过于复杂的话，我们可以使用例外一种方式得到随机数，即Random 类，这个类是专门用来生成随机数的，并且 Math.random()底层调用的就是Random 的 nextDouble()方法。

Random 类的常用方法
在这里插入图片描述

3.System类

在这里插入图片描述

4.包装类

1. 基本类型包装类

Java 是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。

比如：将基本数据类型存储到 Object[ ]数组或集合中的操作等等。
为了解决这个不足，Java 在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

针对八种基本数据类型定义相应的引用类型—包装类（封装类）

有了类的特点，就可以调用类中的方法， Java才是真正的面向对象

常用的操作之一：用于基本数据类型与字符串之间的转换
在这里插入图片描述

2.Integer类

在这里插入图片描述

public static void main(String[] args) {
    // 如果在使用过程中，调用方法的时候，如果方法上画了删除线  则表示该方法不推荐使用，但是 依然可以使用
    Integer integer = new Integer("10");
    //使用Integer来获取最大的整数
    System.out.println(Integer.MAX_VALUE);
    System.out.println(Integer.MIN_VALUE);
    //推荐使用的 获取Integer对象的方法
    // 实现了将基本类型的数据转换为他的包装类对象
    Integer in = Integer.valueOf(100);
    // 将基本类型的String类型转换为基本 类型对应的包装类
    Integer in2 = Integer.valueOf("bac");//字符串中的内容只能为数字  否则就会出现NumberFormatException
}

自动装箱和自动拆箱

Integer in3 = 120;// 自动装箱  始于jdk1.5
int i = in;// 自动拆箱

int和String相互转换

int转换称String
方式1：基本类型数据和字符串拼接

String s = 3 + "";
System.out.println(s + 1);//31

方式2：使用包装类提供的toString方法

package cn.lanqiao.wrapper;

public class IntegerDemo {
    public static void main(String[] args) {
        // 如果在使用过程中，调用方法的时候，如果方法上画了删除线  则表示该方法不推荐使用，但是 依然可以使用
        Integer integer = new Integer("10");
        //使用Integer来获取最大的整数
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //推荐使用的 获取Integer对象的方法
        // 实现了将基本类型的数据转换为他的包装类对象
        Integer in = Integer.valueOf(100);
        // 将基本类型的String类型转换为基本 类型对应的包装类
        Integer in2 = Integer.valueOf("200");//字符串中的内容只能为数字  否则就会出现NumberFormatException
        Integer in3 = 120;// 自动装箱  始于jdk1.5
        int i = in;// 自动拆箱
        String s = 3 + "";
        System.out.println(s + 1);//31
        System.out.println(in2.toString() + 100);//200100
    }
}

方式3：使用String类提供的valueOf

System.out.println(String.valueOf(100) + 100);//100100

String转换为int
方式一：先使用Integer.valueOf将字符串数字转成Integer，再调用intValue()方法转换为int

方式二：通过Integer静态方法parseInt()进行转换 public static int parseInt(String s)

 //将String 类型转换为int类型
    //方式一：先使用Integer.valueOf将字符串数字转成Integer，再调用intValue()方法转换为int
    String str = "1000";
    Integer ii = Integer.valueOf(str);
    // 使用intValue方法
    int ii1 = ii.intValue();
    // 可以使用自动拆箱
    int ii2= ii;
    //方式二通过Integer静态方法parseInt()进行转换 public static int
    int ii3 = Integer.parseInt(str);
}

在这里插入图片描述

public class StrChangInt {
    public static void main(String[] args) {
        String  str = "91 27 46 38 50";
        String[] strArr = str.split(" ");
        Integer[] intArr = new Integer[strArr.length];
        for(int i = 0 ; i < strArr.length;i++){
            intArr[i] = Integer.parseInt(strArr[i]);
        }
        Arrays.sort(intArr);
        for(Integer integer : intArr){
            System.out.println(integer);
        }
    }
}

3.包装类的缓存问题

• 整型、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，其目的是提高效率。

• 缓存处理的原理为：如果数据在-128~127这个区间，那么在类加载时就已经为该区间的每个数值创建了对象，并将这256个对象存放到一个名为cache的数组中。每当自动装箱过程发生时（或者手动调用valueOf()时），就会先判断数据是否在该区间，如果在则直接获取数组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创建对象。下面我们以Integer类为例，看一看Java为我们提供的源码，加深对缓存技术的理解
在这里插入图片描述

public class StrChangInt {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false
        Integer m = 123;
        Integer n = 123;
        // 只要自动装箱的数据的范围在-128---127之间  都是 直接从缓存对象数组中去获取元素
        System.out.println(m == n);//true
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false
    }
}

在这里插入图片描述

十点半吃糖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day_17 内部类，常用API类

内部类在类的内部，创建一个类，这个类就是内部类，包含内部类的类称为外部类内部类分类成员内部类和局部内部类成员内部类public class OuterClass { private int num =10; private int num1 = 20; //成员内部类 public class InnerClass{ private double a = 100.1; public void print(){
复制链接

扫一扫