Java常用类_java int index=random.nextint(names.size());-CSDN博客

本文链接：https://blog.csdn.net/m0_71385552/article/details/128056176

在介绍Java常用类之前先来介绍一下权限修饰符和内部类的使用。

一、访问权限修饰符

在Java中提供了四种访问权限修饰符分别是 public，private，default，protected ，使用不同的访问修饰符修饰时，被修饰的内容会有不同的访问权限。

1. public 访问修饰符

public是公共的访问修饰符，它可以修饰类，成员变量，成员方法，构造方法。被public修饰后，可以在任何一个类中访问到，不管是不是同一个包内，随意调用。

2. private 访问修饰符

private是私有的访问权限修饰符，它可以修饰成员变量，成员方法，构造方法，不能修饰类(此刻指的是外部类，内部类不加以考虑)。被private修饰的成员只能在修饰的类中访问，在其他类中不能调用，但是被private修饰的成员可以通过set和get方法向外界提供访问方式。

代码如下：

public class eee {
    private String name;
    private int age;
    private String address;

    //getter和setter方法
    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;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }


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


//实例化对象进行给私有变量赋值
public class sss {
    public static void main(String[] args) {

        eee eee = new eee();
        //调用set方法用来给私有变量赋值
        eee.setName("张胜男");
        eee.setAge(18);
        eee.setAddress("中国");
        //调用get方法用来获取私有变量的值
        eee.getName();
        eee.getAge();
        eee.getAddress();
        System.out.println(eee);

    }
}

3. protected访问修饰符

protected是保护访问权限修饰符，它可以修饰成员变量，成员方法，构造方法，但不能修饰类(外部类)。被protected修饰后，只能被同包下的其他类访问。如果不同包下的类要访问被protected修饰的成员，这个类必须是成员的子类才可以访问。

4. defalut默认访问修饰符

default默认修饰符，只能被当前类或同包下被调用。它可以修饰类、成员方法、成员变量、构造方法。即不被private、prontected、public修饰。

二、内部类

1.内部类的理解

将Student类定义在另一个Person类的内部。那么Student类就成为内部类，Person类就称为外部类。

2. 成员内部类

成员内部类就是定义在类中方法外的类。

定义格式：

class 外部类{

class 内部类{

}

3.访问特点

①. 内部类可以字节访问外部类的成员，包括私有成员。

②. 外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象的格式：

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

代码如下：

public class Teacher {
    String name;
    class Address{
        String addr;
    }
}



public class Test02 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        Teacher.Address address= teacher.new Address();
        address.addr="sds";

    }
}

3. 匿名内部类

匿名内部类是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。开发中，最常用到的内部类就是匿名内部类了。

匿名内部类必须继承一个父类或者实现一个父接口。

匿名内部类的作用：

①. 如果抽象类或者接口的抽象方法没办法具体定义实现，或者需要根据具体情况具体实现，此时没办法定义子类，可以是哟个匿名内部类。

②. 匿名类可以使代码更加简洁（直接创建子类对象，重写方法，然后调用）

匿名内部类使用方法：

public abstract class Person {
    Stu stu;
    public abstract void say();

}


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

        //匿名内部类
        Teacher teacher=new Teacher() {
            @Override
            public void eat() {
                System.out.println("匿名内部类");
            }
        };

    }
}

三、Scanner常用类

1. next(); (实现基本的数据输入,可以输入任何内容)

public class Test {
    public static void main(String[] args) {
        //定义扫描器用来扫描键盘的输入
        Scanner scanner=new Scanner(System.in);
        //打印输出一个提示信息
        System.out.println("请随即输入内容");
        //使用扫描器对象获得键盘的录入
        String num=scanner.next();
        //使用结果
        System.out.println("你输入的是："+num);
    }
}

2. nextInt(); (只能输入整数，输入其他类型的内容会出现异常)

public class Test {
    public static void main(String[] args) {
        //定义扫描器用来扫描键盘的输入
        Scanner scanner=new Scanner(System.in);
        //打印输出一个提示信息
        System.out.println("请随即输入内容");
        //使用扫描器对象获得键盘的录入
        int num=scanner.nextInt();
        //使用结果
        System.out.println("你输入的是："+num);
    }
}

运行结果如下：

四、Random类

1. Random类的基本用法

public class Test {
    public static void main(String[] args) {
        Random random=new Random(6);//不指定参数，表示每一次都会重新生成一个随机数，传入参数，确定一个种子用来记录，每次生成的随机数是相同的
        int num=random.nextInt(10);//随机生成0-9之间的随机数
        System.out.println(num);
    }
}

2. 使用Scanner和Random生成一个猜数字游戏

public class Demo2 {
    public static void main(String[] args) {
        /*使用Scanner和Random完成一个猜数字游戏
        随机生成一个1-100之间的数字，然后用户猜数字，判断大了提示用户猜大了，
        小了则提示用户猜小了重新猜，猜对了则统计猜的次数*/

        Scanner scanner=new Scanner(System.in);
        Random random=new Random();
        int num1=random.nextInt(100)+1;
        int count=1;
        System.out.println("欢迎来到猜数字游戏，你可以输入1-100之间的整数来进行猜大小");
        do {
            System.out.print("请输入你猜的数字：");
            int input =scanner.nextInt();
            if (input>num1){
                System.out.println("你猜的数字太大了，请重新猜!!!");
            } else if (input<num1) {
                System.out.println("你猜的数字太小了，请重新猜!!!");
            }else {
                System.out.println("恭喜你猜对了!!!");
                break;
            }
            count++;
        }while (true);
        System.out.println("你一共猜了"+count+"次");
    }
}

运行结果如下：

五、ArrayList类

1. 特性

ArrayList类是可以动态修改的数组，没有固定大小的限制。它可以对数据进行添加或删除的操作。

2.使用方法

public class Demo01 {
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList();
        //add 添加数据
        arrayList.add("张三");
        arrayList.add("李四");
        arrayList.add("王五");

        //set 修改数据
        arrayList.set(0,"阿航");

        //get 获取数据
        System.out.println(arrayList.get(2));
        System.out.println("-----------------------");
        System.out.println(arrayList.get(0));

        //删除索引为1的数据
        arrayList.remove(1);

        System.out.println("-------------遍历数据------------------");
        //遍历数据
        for (String  sa:arrayList){
            System.out.println(sa);
        }
        System.out.println("----------------------");
        System.out.println(arrayList.size());

    }
}

3. 使用ArrayList完成一个不重复的点名操作

public class Demo02 {
    public static void main(String[] args) {
        //使用Arrays把数据转换成集合，这个是一个固定的数组形式
        List<String> list= Arrays.asList("张三","李四","王五","贺六","马七","刘八");
        //通过构造方法创建名单集合：把List集合中的元素一一取出存入names集合中
        ArrayList<String> arrayList=new ArrayList<>(list);

        //随机生成数据
        Random random=new Random();
        //键盘录入
        Scanner scanner=new Scanner(System.in);
        while (true){
            if (arrayList.size()==0){
                System.out.println("点名结束");
                break;
            }
            System.out.println("点名请输入Y/y");
            //获取用户输入的数据
            String input = scanner.next();
            if (input.equals("Y") || input.equals("y")){
                //随机产生集合范围内的一个索引值
                int index = random.nextInt(arrayList.size());
                //根据索引获取对应的值
                String name=arrayList.get(index);
                System.out.println("被点到的名字是："+name);
                arrayList.remove(index);
            }else {
                System.out.println("请输入大写Y或者小写y重新运行进行点名");
                break;
            }
        }


    }
}

六、包装类

1.概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建新的对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.long包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

2. 装箱

装箱的含义：装箱就是把基本数据类型转换为包装类

public class Demo03 {
    public static void main(String[] args) {
        int a=30;
        //装箱
        //把int类型的变量a装到包装类中
        Integer a1=new Integer(a);
        
        //使用valueof方法会返回一个表示指定的int值的Integer实例
        Integer a2=Integer.valueOf(a);
    }
}

3. 拆箱

拆箱的含义：拆箱就是把包装类类型转化为基本数据类型

public class Demo03 {
    public static void main(String[] args) {
        int a=30;
        //装箱
        //把int类型的变量a装到包装类中
        Integer a1=new Integer(a);

        //使用valueof方法返回一个Integer类型的
        Integer a2=Integer.valueOf(a);

        //拆箱
        //把Integer类型转化为int基本数据类型称为拆箱
        int b=a1.intValue();
    }
}

4.自动装箱与自动拆箱

public class Demo03 {
    public static void main(String[] args) {
        int a=30;
        //装箱
        //把int类型的变量a装到包装类中
        Integer a1=new Integer(a);

        //使用valueof方法返回一个Integer类型的
        Integer a2=Integer.valueOf(a);

        //拆箱
        //把Integer类型转化为int基本数据类型称为拆箱
        int b=a1.intValue();

        //自动装箱与自动拆箱
        Integer c=a;
        int d=a1;
    }
}

5.基本类型与字符串之间的转换

基本数据类型转字符串类型可以自动转换，而字符串类型转基本数据类型则需要手动转换

6. 扩展

public class Demo04 {
    public static void main(String[] args) {
        Integer a1=100;
        Integer a2=100;
        System.out.println(a1==a2);

        System.out.println("----------------------");Integer b1=130;

        Integer b2=130;
        System.out.println(b1==b2);
    }
}

运行结果如下：