Java_Scanner、Random、ArrayList

Java_Scanner、Random、ArrayList

1.封装性在Java中的体现：方法；关键字private
2.注意事项：如果使用关键字private进行修饰，则在本类中 可以进行访问，如果超出了本类，则不能直接访问
3.间接访问关键字private：定义一对Getter和Setter方法；命名规则为：setXXX或getXXX；对于boolean类型，Getter方法需要写成isXXX的形式，而Setter方法规则不变
示例一 ：

public class student{
    String name;
    private int age;

    public void show(){
    System.out.println("姓名 "+name+"，年龄 "+age);
    }

    //用于向age中设置数据(有参数，无返回值)
    public void setAge(int num){
        if (num>0&&num<100){
            age=num;
        }else{
            System.out.println("数据不合理");
        }
        
    }

    //用于获取age中的数据（无参数，有返回值）
    public int getAge(){
        return age;
    }
}

public class test{
        public static void main(String[] args){
             student name1=new student();
             name1.name="张三";
             name1.setAge(-12);
             name1.show();   
        }
    }

示例二 ：

public class student{
    private String name;
    private int age;
    private boolean male;

    public void setName(String str){
        name=str;
    }

    public String getName(){
        return name;
    }

    public void setAge(int num){
        age=num;
    }

    public int getAge(){
        return age;
    }

    public void setMale(boolean b){
        male=b;
    }

    public boolean isMale(){
        return male;
    }
}

public class test{
        public static void main(String[] args){
                student stu=new student();
                stu.setName("张三");
                stu.setAge(28);
                stu.setMale(true);

                System.out.println("姓名 "+stu.getName());
                System.out.println("年龄 "+stu.getAge());
                System.out.println("是否为男 "+stu.isMale());
        }
    }

// 姓名 张三
// 年龄 28
// 是否为男 true

4.this关键字的作用

public class student{
    //成员变量name是自己的名字
    String name;

    //参数name是对方的名字，当重名时根据就近原则，优先使用局部变量（参数）
    //解决方案:this.成员变量名
    public void sayHello(String name){
        System.out.println(name+"，你好 ，我是"+this.name);
    }

}

public class test{
        public static void main(String[] args){
                student stu=new student();
                stu.name="张三";
                stu.sayHello("李四");
        }
}
//李四，你好 ，我是张三

5.构造方法
（1）格式：

public 类名称（参数类型 参数名称）{
        方法体;
}

（2）注意事项：

• 构造方法的名称必须和所在类的名称完全一样，就连大小写也保持一致
• 构造方法不写返回值，无void
• New对象就是在调用构造方法
• 如果没有编写任何构造方法，则编译器会自动产生一个构造方法，无参数，无方法体，具体格式为：public 类名称（）{}
• 一旦编写了至少一个构造方法，则编译器不再自动生成

public class student{
    // 成员变量
    private String name;
    private int age;

    //无参构造方法
    public student(){
        System.out.println("调用构造方法！！！");
    }

    //全参构造方法(重载)
    public student(String name,int age){
        System.out.println("调用全参构造方法！！！");
        this.name=name;
        this.age=age;
    }

    //调用Setter和Getter方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }
}

public class test{
        public static void main(String[] args){
                student stu1=new student();//调用无参构造
                stu1.setName("liming");
                stu1.setAge(45);
                System.out.println("姓名 "+stu1.getName()+",年龄  "+stu1.getAge());
                System.out.println("=================");
                
                student stu2=new student("张三",23);//调用全参构造
                System.out.println("姓名 "+stu2.getName()+",年龄  "+stu2.getAge());
                
                //改变姓名
                stu2.setName("李四");
                System.out.println("姓名 "+stu2.getName()+",年龄  "+stu2.getAge());
        }       
    }

// 调用构造方法！！！
//姓名 liming,年龄  45
// =================
// 调用全参构造方法！！！
// 姓名 张三,年龄  23
// 姓名 李四,年龄  23

6.一个标准的类（Java Bean）包含以下四个部分：

• 所有的成员变量都要使用private关键字来修饰
• 为每一个成员变量定义一对Setter和Getter方法
• 编写一个无参的构造方法
• 编写一个全参的构造方法

public class student{
    // 成员变量
    private String name;
    private int age;

    //无参构造方法
    public student(){
        System.out.println("调用构造方法！！！");
    }

    //全参构造方法(重载)
    public student(String name,int age){
        System.out.println("调用全参构造方法！！！");
        this.name=name;
        this.age=age;
    }

    //调用Setter和Getter方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }
}

7.Scanner类
（1）Scanner类的功能：可以实现键盘输入数据
（2）引用类型的一般使用步骤：

• 导包：import 包路径.类名称；
• 创建：类名称 对象名=new 类名称（）；
• 使用：对象名.成员方法名（）；

//1.导包
import java.util.Scanner;

public class test{
        public static void main(String[] args){
                //2.创建
                Scanner src=new Scanner(System.in);

                //3.获取键盘的int类型数字
                int num=src.nextInt();
                System.out.println(num);

                //4.获取键盘的String类型字符串
                String str=src.next();
                System.out.println(str);
        }
    }

（3）键盘输入两个数字，求出和值

public class test{
    public static void main(String[] args){
        Scanner src=new Scanner(System.in);
        //第一个数字：
        System.out.println("请输入第一个数字：");
        int num1=src.nextInt();

        //第二个数字：
        System.out.println("请输入第二个数字：");
        int num2=src.nextInt();

        //求和
        int result=num1+num2;
        System.out.println("和值为： "+result);
    }
}

（4）键盘输入三个数字，求其中的最大值

public class test{
    public static void main(String[] args){
            Scanner src=new Scanner(System.in);

            System.out.println("请输入第一个数字：");
            int a=src.nextInt();

            System.out.println("请输入第二个数字：");
            int b=src.nextInt();
            
            System.out.println("请输入第三个数字：");
            int c=src.nextInt();

            //比较大小
            int num=a>b?a:b;
            int max=num>c?num:c;
            System.out.println("最大值为： "+max);
        
    }
}

8.匿名对象
（1）格式：new 类名称();
（2）注意事项：匿名对象只能使用唯一的一次，如果再次使用需要再重新创建一个对象
（3）使用建议：如果确定对象只使用唯一的一次，则可以使用匿名对象

public class test{
    public static void main(String[] args){
        //普通方式
        // Scanner src=new Scanner(System.in);
        // int num=src.nextInt();
        // System.out.println("输入是数值是： "+num);

        //使用匿名对象
        int num=new Scanner(System.in).nextInt();
        System.out.println("输入是数值是： "+num);
    }
}

9.Random类
（1）功能：生成随机数字
（2）使用步骤：

• 导包：import java.util.Random;
• 创建：Random r=new Random();
• 使用：（不限定范围）int num=r.nextInt(); （限定范围：左闭右开）int num=r.nextInt(x)
  示例一：不限定范围

public class test{
    public static void main(String[] args){
        Random r=new Random();
        int num=r.nextInt();
        System.out.println("生成的数字是："+num);
    }
}

示例二：限定范围

//循环100次，生成的随机数在0-9之间
public class test{
    public static void main(String[] args){
        Random r=new Random();
        for(int i=0;i<100;i++){
                int num=r.nextInt(10);
                System.out.println("生成的数字是："+num);
                
        }
    }
}

示例三：范围发生变化

//给定一个数字n，来获取随机数字，循环100次，使其范围在[1,n]
public class test{
    public static void main(String[] args){
            Random r=new Random();
            int n=8;
            for(int i=0;i<100;i++){
                    int result=r.nextInt(n)+1; //[1,8]
                    System.out.println("生成的数字是： "+result);
            }
           
    }
}

示例四：猜数字游戏

public class test{
    public static void main(String[] args){
        //生成随机数
        Random r=new Random();
        int randomNum=r.nextInt(100)+1;

        while(true){
                //从键盘输入的数字
                Scanner src=new Scanner(System.in);
                System.out.println("请输入你猜测的数字：");
                int gussNum=src.nextInt();

                //进行猜数字游戏
                if(gussNum>randomNum){
                        System.out.println("太大了，请重试！！！");
                }else if(gussNum<randomNum){
                        System.out.println("太小了，请重试！！！");
                }else{
                        System.out.println("猜对了！！！");
                        break;
                }
        }
        System.out.println("游戏结束！！！");
    }
}

10.ArrayList类
（1）优点：可以改变数组长度
（2）ArrayList后面的尖括号里面只能是引用类型，不可以是基本类型
（3）对于ArrayList集合来说，直接打印得到的不是地址值，而是内容，如果内容为空，则得到的是[ ]
（4）ArrayList中的常用方法

• public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致
• public E get(int index)：从集合中获取元素，参数是索引编号，返回值就是对应位置的元素
• public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删掉的元素
• public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数

public class test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        System.out.println(list);
        System.out.println("===============");

        //添加元素
        list.add("张三"); //只能逐一添加
        list.add("李四");
        list.add("李明");
        list.add("詹妮");
        System.out.println(list);
        System.out.println("===============");

        //获取元素
        String getName=list.get(2);
        System.out.println("获取的元素是： "+getName);
        System.out.println(list);
        System.out.println("===============");

        //删除元素
        String removeName=list.remove(3);
        System.out.println("删除的元素是： "+removeName);
        System.out.println(list);
        System.out.println("===============");

        //获取元素长度
        int num=list.size();
        System.out.println("数组的长度是： "+num);
        System.out.println(list);
        System.out.println("===============");

        //遍历集合
        for(int i=0;i<list.size();i++){
                System.out.println(list.get(i));
        }
    }
}

（5）如果向ArrayList中存储基本数据类型，需要借助“包装类”

• byte---->Byte
• short---->Short
• int---->Integer
• long---->Long
• float---->Float
• double---->Double
• char---->Character
• boolean---->Boolean

public class test{
    public static void main(String[] args){
        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);
    }
}

示例一：生成六个1-33之间的随机整数，添加到集合之后遍历集合

public class test{
    public static void main(String[] args){
        ArrayList<Integer> list=new ArrayList<>();
        Random r=new Random();
        for(int i=0;i<6;i++){
                int num=r.nextInt(33)+1;
                list.add(num);
        }

        //遍历集合
        for(int i=0;i<list.size();i++){
                System.out.println(list.get(i));
        }
    }
}

示例二：自定义4个学生对象，添加到集合，并遍历

public class student{
    // 成员变量
    private String name;
    private int age;

    //无参构造方法
    public student(){
        System.out.println("调用构造方法！！！");
    }

    //全参构造方法(重载)
    public student(String name,int age){
        System.out.println("调用全参构造方法！！！");
        this.name=name;
        this.age=age;
    }

    //调用Setter和Getter方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }
}

public class test{
    public static void main(String[] args){
        //创建集合
        ArrayList<student> list=new ArrayList<>();

        //创建对象
        student one=new student("张三",56);
        student two=new student("李四",89);
        student three=new student("李明",24);
        student four=new  student("詹妮",78);

        //添加到集合
        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);

        //遍历集合
        for(int i=0;i<list.size();i++){
                //获取集合
                student stu=list.get(i);
                System.out.println("姓名 "+stu.getName()+",年龄 "+stu.getAge());
        }

    }
}

示例三：以指定格式打印集合，使用{ }括起集合，使用@分割每个元素

public class test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("李明");
        list.add("詹妮");
        printArray(list);
        // System.out.println(list);
    }

    //定义指定格式打印
    public static void printArray(ArrayList<String> list){
        System.out.print("{");
        for(int i=0;i<list.size();i++){
                String name=list.get(i);
                if(i==list.size()-1){
                        System.out.print(name+"}");
                }else{
                        System.out.print(name+"@");
                }
        }
    }
}

示例四：筛选集合中的偶数

public class test{
    public static void main(String[] args){
        //创建一个大集合
        ArrayList<Integer> bigList=new ArrayList<>();
        //产生随机数并且添加到大集合中
        Random r=new Random();
        for(int i=0;i<20;i++){
                int num=r.nextInt(100)+1;
                bigList.add(num);
        }
        
        ArrayList<Integer> smallList=getSmallList(bigList);
        System.out.println("偶数一共多少个："+smallList.size());
        
        //打印小集合中的元素
        for(int i=0;i<smallList.size();i++){
                System.out.println(smallList.get(i));
        }
    }

    public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList){
        //创建一个小集合    
        ArrayList<Integer> smallList=new ArrayList<>();
        //遍历大集合
        for(int i=0;i<bigList.size();i++){
                int num=bigList.get(i);
                //如果为偶数，则添加到小集合中
                if(num%2==0){
                        smallList.add(num);
                }
        }
        return smallList;
    }
}