JavaSE学习之内部类及常用API-编程学习网

1.内部类

1.1 内部类概述

内部类：就是在一个类中定义一个类。例如：在一个类A内部定义一个类B，类B就被称为内部类

格式：public class 类名{修饰符 class 类名{}}

范例


public class Outer{
   public class Inter{//内部类
   }
}

内部类的访问特点

1. 内部类可以直接访问外部类成员，包括私有

2. 外部类如果想访问内部类就要创建对象

举例


public class Outer {//创建外部类
    private  int age=9;
    public class Inter{//创建内部类
        //内部类创建方法
        public void show(){
            //内部类可直接访问外部类
            System.out.println(age);
        }
    }
    public void method(){
        //这里是外部类的调用，那么不能直接像下面一样调用show()方法，
        //不然就会报错，不能直接访问
        //show();不能这样
        //应改为创建内部类对象，通过对象进行访问
         Inter i=new Inter();
         i.show();
    }
}

1.2 成员内部类

按照内部类在类中的位置不同，可以分为两种形式

在类的成员位置：成员内部类
在类的局部位置：局部内部类


//类
public class Outer {//创建外部类
    private  int age=9;
    public class Inter{//创建内部类
        //内部类创建方法
        public void show(){
            //内部类可直接访问外部类
            System.out.println(age);
        }
    }
  }


//测试类

在这里插入图片描述

那么怎么不让它报错呢？如何创建呢

外部类.内部类对象名=new 外部类.new内部类();
Outer.Inter oi=new Outer().new Inter();


//测试类
public class Main {
    public static void main(String[] args) {
     Outer.Inter oi=new Outer().new Inter();//构造内部类对象
     oi.show();
    }
}

但是，一般情况下，为了安全性不会将内部类定义为公有，会设置为私有，上面的Outer.Inter oi=new Outer().new Inter();就不能这样构造内部类的对象了，否则就会报错，那么该如何创建呢？

很简单，因为外部类可以通过创建内部类的对象进行访问内部类，那么就可以在测试类中写外部类的方法，从而进行间接访问。


//类
public class Outer {//创建外部类
    private  int age=9;
   private class Inter{//创建内部私有类
        //内部类创建方法
        public void show(){
            //内部类可直接访问外部类
            System.out.println(age);
        }
    }
    public void method(){
    Inter i=new Inter();//创建内部类对象间接访问
    i.show();  //调用方法             
    }
  }

这样就可以输出内部类的值了

运行结果

9

1.3 局部内部类

局部内部类是在方法中定义的类，所以外界是无法访问的，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问方法内部的局部变量


//类
public class Outer {//创建外部类
    private int age = 9;

    public void method() { //在方法中局部创建内部类

        class Inter {//创建内部类
            private int age2 = 2;//局部变量也可以

            public void show() {
                System.out.println(age);
                System.out.println(age2);
            }
        }
        Inter i = new Inter();//创建内部类对象间接访问
        i.show();  //调用方法
    }
}


public class Main {
    public static void main(String[] args) {
     Outer o=new Outer();
     o.method();//间接调用方法
    }
}

1.4 匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类，也可以是抽象类
格式：new 类名或者接口名(){重写方法}
范例：new Inter(){public void show(){}};
解释： new Inter()是匿对象，继承了这个类，或实现了这个接口
本质：是一个继承了该类或者实现了该接口的子类匿名对象,

匿名内部类是局部内部类的一种形式，写的时候也应该在方法中


//前提：一个类或者接口
public interface Inter {//写接口
    void show();//写抽象方法
}

那么既然是对象，就可以通过对象调用方法


public class Outer {//创建外部类

    public void method() {
     new Inter() {//这个是对象
         @Override//重写方法
         public void show() {
             System.out.println("匿名内部类");
         }
     }.show();//通过对象调用方法
    }
}

这块是重点：new Inter() {//这个是对象 @Override//重写方法 public void show() { System.out.println("匿名内部类"); } }.show();//通过对象调用方法，这里采用了对象调用方法，上面整体是对象，然后.show()调用方法


//测试类
public class Main {
    public static void main(String[] args) {
     Outer o=new Outer();
     o.method();//调用方法
    }
}

接下来，有个疑问，你会说，如果我想多次调用方法，是不是要写很多次这个方法呢？答案是否定的，既然是内部类，那么就可以通过多态形式进行，即：Inter i=new Inter(){};然后通过i来调用show()方法


public class Outer {//创建外部类

    public void method() {
    Inter i =new Inter() {//多态形式，左面接口名，右面对象
         @Override//重写方法
         public void show() {
             System.out.println("匿名内部类");
         }
     };
     i.show();//遵循编译看左面，执行看右面
     i.show();
    }
}

1.5 匿名内部类在开发中的使用

学完了匿名内部类之后，那么它在开发中有哪些运用呢？

在开发时，如果要实现一个接口方法时，不需要再创建类，比如之前写的猫跳高了，如果想写狗跳高了还要重建一个类，这样显得太过于繁琐，而且占用空间，既然内部类本质是类的对象，那么直接使用就会大量降低代码的低效性


//接口
public interface Jummping {
    void jump();//抽象类
}


//操作类
public class JumppingOperator {
    public void useOperator(Jummping j){//接口名作为形参，new Jumpping(){}
        j.jump();//内部类对象调用方法
    }


public class Jumpping {
    public static void main(String[] args) {
        JumppingOperator j = new JumppingOperator();//创建操作类对象
        j.useOperator(new Jummping() {
            @Override
            public void jump() {
                System.out.println("猫跳高了");
            }
        });//用匿名内部类实现
        //重复使用，就不用再创建Cat类或者Dog类了
        j.useOperator(new Jummping() {
            @Override
            public void jump() {
                System.out.println("狗跳墙了");
            }
        });
    }
}

2.常用API

2.1Math

public final class Math extends Object被final修饰，是最终类，详细内容见APi手册

在这里插入图片描述

通过帮助文档知道，它没有构造方法，那么如何使用类中的成员呢？

这时候就需要看成员是否都是静态的，如果是，通过类名就可以直接调用

常用方法

在这里插入图片描述


public class Main {
        public static void main(String[] args) {
                //绝对值
                System.out.println(Math.abs(-88));
                System.out.println(Math.abs(88));
                System.out.println("----------");
                //返回大于或者等于参数的double值为一个整数,（向上取整）
                System.out.println(Math.ceil(1.12));
                System.out.println("----------");
                //返回0小于或者等于参数的double值为一个整数,（向下取整）
                System.out.println(Math.floor(1.21));
                System.out.println("----------");
                //返回最大值
                System.out.println(Math.max(1,2));
                System.out.println("----------");
                //返回最小值
                System.out.println(Math.min(2,6));
                System.out.println("----------");
                //返回a的b次幂
                System.out.println(Math.pow(2,2));
                System.out.println("----------");
                //返回四舍五入的整数值
                System.out.println(Math.round(1.51));
                System.out.println("---------");
                //返回随机值，[0-1.0)
                System.out.println(Math.random());
                //返回1-100整数随机值
                System.out.println((int)(Math.random()*100)+1);


        }
}

运行结果

88

88

----------

2.0

----------

1.0

----------

2

----------

2

----------

4.0

----------

2

---------

0.6041376042702374

78

2.2 System

在这里插入图片描述

不能实例化，不能创建对象，静态修饰

常用方法

在这里插入图片描述


public class Main {
        public static void main(String[] args) {
                System.out.println("start");
                System.exit(0);
                //java虚拟机已经停止运行，无法在进行执下面的语句
                System.out.println("end");
        }
}

运行结果

start


public class Main {
        public static void main(String[] args) {
                System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+"年");
                System.out.println("开始计算下面程序执行的时间");
               long start=System.currentTimeMillis();//用lang定义，因为数字太大
                for(int i = 0; i <10000;i++){
                        System.out.println(i);
                }
                long end=System.currentTimeMillis();//用lang定义
                System.out.println("程序运行时间为："+(end-start)+"毫秒");
        }
}

2.3 Object

概述

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类

构造方法: public Object(）

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法?

因为它们的顶级父类只有无参构造方法心

toString()方法的使用

可以使得单独的多个属性变得有联系，让人一眼就能够看明白什么意思，例如我们在前面讲到的创建学生实体类时，在测试类输出时还要用getXxx()+setXxx才能进行输出，有了这种方法，我们就可直接进行使用了，这个方法建议所有子类进行重写使用，在使用时可以直接使用方法，快捷键还是Alt+Inster下面可以看到toString()方法

下面进行举例:


public class Student {//其实这里继承了Object,所以Student这个类理论上是子类，
//所以可以使用toString()方法，但要重写
    private String name;
    private  int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {//重写方法
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在这里插入图片描述


//测试类
public class Main {
        public static void main(String[] args) {
            Student s=new Student("张三",18);//采用有参构造
                System.out.println(s);//因为使用了toString()方法，
                // 就不用再用getName(),getAge()输出了，直接输出s

        }
}

运行结果

Student{name='张三', age=18}

这样就可以让他们之间建立一种联系

equal()方法

在这里插入图片描述

比较的是内容值，当然，如果按照上面的方法进行比较姓名，年龄，它返回的的地址，因为地址不同，那么就会返回false,这个还需要在子类中重写方法，快捷键依然是那个

在这里插入图片描述

然后一直点下一步

再删掉这部分即可

在这里插入图片描述


//测试类
public class Main {
        public static void main(String[] args) {
            Student s1=new Student("张三",18);//采用有参构造
                System.out.println(s1);
                Student s2=new Student("张三",18);//采用有参构造
                System.out.println(s2);
                 System.out.println(s1.equals(s2));
                 //这里因为是new出来的，所以比较地址就会返回false，那么只有重写了方法才会
                
        }
}


//学生类
public class Student {
    private String name;
    private  int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

}

这是对equals()方法代码内容的解释

在这里插入图片描述

2.4 Array的排序

对于封装好的排序方法，不用岂不是太可惜，但是用之前我们也要思考自己能否写出一个高效的算法排序的方法。

下面进行介绍Arrays类的使用，由于APi中方法太多，详细内容还请到API中自行查看，这里讲述两种常用的方法：

在这里插入图片描述

工具类的设计思想:

1. 构造方法用private修饰：为了防止外界创建对象

2. 成员用public static修饰：使用类名来访问该成员变量


import java.util.Arrays;

public class Main {
        public static void main(String[] args) {
           int []arr={2,7,3,4,9,5};
            System.out.println("排序前: "+Arrays.toString(arr));
            Arrays.sort(arr);
            System.out.println("排序后: "+Arrays.toString(arr));

        }
}

运行结果：

排序前: [2, 7, 3, 4, 9, 5]

排序后: [2, 3, 4, 5, 7, 9]

现要求从键盘录入数字，要求数组是动态的，对数据进行排序


public class Main {
        public static void main(String[] args) {

            Scanner sc=new Scanner(System.in);
            System.out.println("请你输入一个数n:");
            int []arr=new int[sc.nextInt()];//动态数组
            for(int i=0;i< arr.length; i++){
                arr[i]=sc.nextInt();
            }
            Arrays.sort(arr);
            System.out.println("排序后:"+Arrays.toString(arr));
        }
}

录入：

1 5 3 7 9

运行结果：

[1, 3, 5, 7, 9]

以上就是JavaSE学习之内部类及常用API的详细内容，更多关于JavaSE内部类 API的资料请关注编程网其它相关文章！

文章详情

JavaSE学习之内部类及常用API

目录

1.内部类

1.1 内部类概述

1.2 成员内部类

1.3 局部内部类

1.4 匿名内部类

1.5 匿名内部类在开发中的使用

2.常用API

2.1Math

2.2 System

2.3 Object

2.4 Array的排序

软考中级精品资料免费领

相关文章

猜你喜欢

JavaSE学习之内部类及常用API

JavaSE中内部类及常用API有哪些

java内部类之成员内部类、局部内部类和匿名内部类用法及说明

Python学习之str 以及常用的命令

Java内部类和异常类的概念以及使用

InfluxDB学习之InfluxDB常用函数（一）聚合类函数

Java基础学习之ArrayList类概述与常用方法

InfluxDB学习之InfluxDB常用函数（三）变换类函数

InfluxDB学习之InfluxDB常用函数（二）选择类函数

String类的学习笔记(上):介绍String类及其常用方法的使用

从零开始学习 Java：简单易懂的入门指南之抽象类&接口&内部类（十一）

从零开始学习 Java：简单易懂的入门指南之抽象类&接口&内部类（十一）