Java_Day17(内部类、常用API、包装类)

最新推荐文章于 2024-01-22 16:37:59 发布

hrh1276

最新推荐文章于 2024-01-22 16:37:59 发布

阅读量99

点赞数

分类专栏： Java语言基础与面向对象编程实践文章标签： java

本文链接：https://blog.csdn.net/weixin_47469183/article/details/111515472

版权

Java语言基础与面向对象编程实践专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Java_Day17(内部类、常用API、包装类)

内部类

在类的内部创建一个类，这个类就称为内部类

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

内部类在开发过程中使用一般以匿名内部类的形式
往往以方法的形参（抽象类和接口的形式出现）和实参来传递使用

成员内部类

在类的声明上可以使用访问权限修饰符
可以在内部类中直接使用外部类的成员
在其他类中如果要使用成员内部类需要创建内部类的对象
内部类引用名称 = new 外部类.new 内部类
在成员内部类中不能使用static

包含内部类的类称为外部类

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

Math（应用）

概述
Math 包含执行基本数字运算的方法
调用方式
Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用
常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int
public static int max(int a,int b)	返回两个int值中的较大值
public static int min(int a,int b)	返回两个int值中的较小值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值，[0.0,1.0)

Random 类（应用）

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

System（应用）

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)

包装类

基本类型包装类

Java 是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。
比如：将基本数据类型存储到 Object[ ]数组或集合中的操作等等。
为了解决这个不足，Java 在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。
针对八种基本数据类型定义相应的引用类型—包装类（封装类）
有了类的特点，就可以调用类中的方法， Java才是真正的面向对象

常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回一个保存指定值的 Integer 对象 String

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类型

一个基本类型的数据和字符串拼接就可以实现将基本类型转换为String

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

使用包装类提供的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
    }
}

使用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);
}

案例：字符串中数据排序

需求：有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”
思路：

将字符串按照空格分割成一个字符串数组
将其中的每一个元素转换为数字
将转换后的数字保存到一个整型数组中
使用Arrays提供的排序方法或者使用我们自己写的排序方法对数组进行排序

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);
        }
    }
}

包装类的缓存问题

整型、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
    }
}

在这里插入图片描述

hrh1276

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java_Day17(内部类、常用API、包装类)

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

扫一扫