Java Day10

最新推荐文章于 2024-07-30 20:50:32 发布

丨陈墨瞳丨

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量32

点赞数

分类专栏： Java 文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/qq_51944132/article/details/132346836

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Java

day10——2023.8.17

常用类

Object类

Object是Java中，类结构的根类，所有的类都是直接或者间接继承Object类

Object类有一个默认的无参构造方法，用来给子类访问

Object类中的方法

需要掌握：

1，boolean equals(Object obj) 指示一些其他对象是否等于此。

2，int hashCode() 返回对象的哈希码值。

3，String toString() 返回对象的字符串表示形式。

需要了解：

4，protected Object clone() 创建并返回此对象的副本。

5，protected void finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象

6，类<?> getClass() 返回此 Object的运行时类。

public class Student implements Cloneable {
    private String name;
    private int age;

    public Student() {
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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

public class TestStudent {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("张三", 20);
        //调用克隆方法
        Object o = s1.clone();
        Student s2 = (Student)o;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);
    }
}

System类

System类包含几个有用的类字段和方法。它不能被实例化。

System类提供的System包括标准输入，标准输出和错误输出流;

访问外部定义的属性和环境变量; 一种加载文件和库的方法; 以及用于快速复制数组的一部分的实用方法。

System类中的方法

1.static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置复制到目标数组的指定位置。

         int[] arr = {10,20,30,40,50};
        int[] arr1 = {100,200,300,400,500};
        //当前数组复制指定数组中的内容，替换当前数组指定位置的内容
        System.arraycopy(arr,2,arr1,3,2);

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));

2.static long currentTimeMillis() 返回当前时间（以毫秒为单位）。

//当前时间的毫秒值，一般用来在某段代码执行的前后分别返回，用来计算程序的执行时间
        System.out.println(System.currentTimeMillis());

3.static void exit(int status) 终止当前运行的Java虚拟机。

for (int i = 0; i < 10; i++) {
            System.out.println(i);
            if (i == 5){
                //表示终止当前正在运行的Java虚拟机，也就是结束程序
                //一般，非0的状态码表示异常终止
                System.exit(0);
            }
        }

4.static void gc() 运行垃圾回收器。

结合finalize()方法，观察gc()方法对于垃圾对象的回收，只有没有被引用的对象才会被gc()方法明确的回收

public class Student implements Cloneable {
   
    @Override
    protected void finalize() throws Throwable {
        System.out.println("对象被回收了,finalize()方法自动被调用了！");
    }
}

public class TestStudent {
    public static void main(String[] args) throws CloneNotSupportedException {
      
        Student s1 = new Student();
         new Student();
         new Student();
         new Student();
         System.gc();
    }
}

包装类（会用）

概念：基本数据类型，没有方法可以使用，将来如果需要完成基本数据类型的转换，不太方便，所以系统提供了包装类，包装类其实是将基本类型，以对象的形式表示出来，提供了一些方法，可以调用，从而是基本类型间接的使用对象的方法。

将来java集合中，只能存放对象，所以想要在集合中存放基本数据类型，必须要以包装类的形式存放。

基本数据类型对应的包装类：

byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	character
boolean	Boolean

Tips：

Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。

Integer(String s) 构造一个新分配 Integer对象，表示 int由指示值 String参数
包装类特点：

1.构造方法：除了Charcter类之外，其他的包装类，都可以用它的基本类型的数据或者一个字符串作为参数，来构造对应的包装类对象

2，普通方法：包装类通用的一些方法

//1,XXXValue:将包装类转为基本类型

//2,toString() 将包装类以字符串的形式返回

//3,valueOf() 包装类都有一个valueOf方法

注意，传入字符串的时候，不能随便传，要符合对应的类型

//4,parseXXX : 将字符串转换为对应包装类的基本数据类型

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

        Integer i1 = new Integer(123);
        //1,XXXValue:将包装类转为基本类型
        int i2 = i1.intValue();
        //2,toString() 将包装类以字符串的形式返回
        String i3 = i1.toString();
        //3,valueOf()  包装类都有一个valueOf方法
        //通过类名直接调用，传入字符串或者基本类型，返回包装类型
        //注意，传入字符串的时候，不能随便传，要符合对应的类型
        Integer i4 = Integer.valueOf("100");

        //4,parseXXX  : 将字符串转换为对应包装类的基本数据类型
        int i5 = Integer.parseInt("100");


        Float f1 = new Float(3.3);
        //1,XXXValue:将包装类转为基本类型
        float f2 = f1.floatValue();

        Boolean b1 = new Boolean(true);
        //1,XXXValue:将包装类转为基本类型
        boolean b2 = b1.booleanValue();

        Character c1 = new Character('A');
        //1,XXXValue:将包装类转为基本类型
        char c2 = c1.charValue();
        //Character类的valueof没有字符串类型的参数
        Character.valueOf('a');
    }
}

jdk1.5新特性：自动装箱和自动拆箱

    	//创建包装类对象
        //Integer i = new Integer(100);
        
        //自动装箱，将基本类型的值，直接赋值给对应的包装类对象
        //系统其实省略一个步骤： 
        //Integer.valueOf(100);
        Integer i = 100;
        Character c = 'a';
        
        //自动拆箱,将包装类型的对象，直接赋值给对应基本类型变量
        //中间省略调用intValue()方法这个步骤
        //int i1 = i.intValue();
        int a = i;  //直接把包装类对象，赋值给基本类型的变量

Integer类型

构造方法:

Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。

Integer(String s) 构造一个新分配 Integer对象，表示 int由指示值 String参数

普通方法：

static String toBinaryString(int i) 在基数2中返回整数参数的字符串表示形式为无符号整数。

static String toHexString(int i) 返回整数参数的字符串表示形式，作为16位中的无符号整数。

static String toOctalString(int i) 在基数8中返回整数参数的字符串表示形式为无符号整数。

String和int类型的转换：

    	// int  -> String
        int num = 100;
        //方式1：
        String s1 = num + "";
        //方式2:
        String s2 = String.valueOf(num);
        //方式3：   int -> Integer -> String
        Integer i = new Integer(num);
        String s3 = i.toString();
        //方式4： 
        String s4 = Integer.toString(num);
        
        
        //String->int
        
        String str = "200";
        //方式1:
        int i1 = Integer.parseInt(str);
        
        //方式2：
        Integer integer = new Integer(str);
        int i2 = integer.intValue();

Integer类的缓冲区

 //如果Integer对象的值，以值形式直接赋值的话
        //值在-128~127 的范围内，数值会从 缓冲区中直接拿取，
        // 判断对象是否相等，返回true
        //超过这个返回，判断相等返回false
        Integer i1 = 127;
        Integer i2 = 127;

        System.out.println(i1 == i2); //true

        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3 == i4); //false

Character类

Character类包装一个对象中的基本类型char的值。类型为Character的对象包含一个单一字段，其类型为char 。

此外，该类还提供了几种方法来确定字符的类别（小写字母，数字等），并将字符从大写转换为小写，反之亦然。

构造方法：

Character(char value) 构造一个新分配的 Character对象，代表指定的 char值。

普通方法：

static boolean isDigit(char ch) 确定指定的字符是否是数字。
static boolean isLetter(char ch) 确定指定的字符是否是一个字母。
static boolean isLowerCase(char ch) 确定指定的字符是否是小写字符。
static boolean isUpperCase(char ch) 确定指定的字符是否为大写字符。
static String toString(char c) 返回一个 String对象，表示指定的 char 。
static char toLowerCase(char ch) 使用UnicodeData文件中的大小写映射信息将字符参数转换为小写。
static char toUpperCase(char ch) 使用UnicodeData文件中的案例映射信息将字符参数转换为大写

/*
测试Character类的常用方法
 */
public class Demo05 {
    public static void main(String[] args) {
        //char c = 'a';
        //System.out.println(Character.isDigit(c));// false
        //System.out.println(Character.isLowerCase(c));// true
        //System.out.println(Character.isUpperCase(c));// false
        //System.out.println(Character.isLetter(c));//true
        //System.out.println(Character.toUpperCase(c));//A
        //System.out.println(Character.toLowerCase(c));//a

        //让用户输入一段字符串数字加大小写字母混合，比如：asgsa2412fafGVSD312dfa
        //这段字符串中，有几个数字、几个小写字母、几个大写字母

        //1,创建输入对象，输入字符串，声明字符串
        String s = "asgsa2412fafGVSD312dfa";
        //2，将字符串转成字符数组
        char[] chars = s.toCharArray();
        //3，遍历数组
        //声明统计变量，三个
        int a = 0, b = 0, c = 0;
        for (int i = 0; i < chars.length; i++) {
            //3.1判断每个字符是什么，数字、小写字母、大写字母
            char ch = chars[i];
            //3.2判断之后给对应的统计变量做++
            if (Character.isDigit(ch)) { //如果是数字
                a++;
            }
            if (Character.isLowerCase(ch)){ //如果是小写字母
                b++;
            }
            if (Character.isUpperCase(ch)){ //如果是大写字母
                c++;
            }
        }
        //4，输出统计变量
        System.out.println("数字:" + a + ",小写字母：" + b + ",大写字母：" +c);
    }
}

其他类

Math类

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

常用方法：

static double ceil(double a) 返回大于或等于参数的最小（最接近负无穷大） double值，等于一个数学整数。

static double floor(double a) 返回小于或等于参数的最大（最接近正无穷大） double值，等于一个数学整数

static int max(int a, int b) 返回两个 int值中的较大值。

static int min(int a, int b) 返回两个 int的较小值。

static double random() 返回值为 double值为正号，大于等于 0.0 ，小于 1.0 。

static long round(double a) 返回参数中最接近的 long ，其中 long四舍五入为正无穷大。

//Math演示
public class Demo06 {
    public static void main(String[] args) {

        System.out.println(Math.ceil(3.25)); // 4
        System.out.println(Math.floor(3.25)); //3
        System.out.println(Math.max(10,10.2)); //10.2
        System.out.println(Math.min(10,5));  //5
        System.out.println(Math.round(2.58));//3

        System.out.println(Math.random());

        //通过random()方法得到1-10之间的随机整数
        System.out.println(Math.ceil(Math.random() * 10));

        //11-20之间随机整数
        System.out.println(Math.ceil(Math.random() * 10 + 10));
    }
}

Random类

生成随机数的类

构造方法：

Random() 创建一个新的随机数生成器。

Random(long seed) 使用单个 long种子创建一个新的随机数生成器。

普通方法：

int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。

int nextInt(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。

protected int next(int bits) 生成下一个伪随机数。

long nextLong() 返回下一个伪，均匀分布 long从这个随机数生成器的序列值
long从这个随机数生成器的序列值

//Random类
public class Demo07 {
    public static void main(String[] args) {
        //无参构造的random对象
        Random random = new Random();
        int i = random.nextInt();
        System.out.println(i);
        int i1 = random.nextInt(100);
        System.out.println(i1);

        Random random1 = new Random(2000);
        int i2 = random1.nextInt();
        System.out.println(i2);
        int i3 = random1.nextInt(100);
        System.out.println(i3);
    }
}

练习：
//写一个猜数字的小游戏
//提示用户，1-100随机数已经生成，让用户输入数值猜生成随机数大小
//如果猜小了，返回你猜小了
//猜大了，返回你猜大了
//猜中了，返回你猜对了，太棒了
//超过10次为猜中，游戏技术，并返回你太菜了，10次都没猜中！告诉他正确答案

import java.util.Random;
import java.util.Scanner;


/*
写一个猜数字的小游戏，
提示用户，1-100随机数已经生成，
让用户输入数值猜生成随机数大小，
如果猜小了，生成猜小了，
如果猜大了说猜大了，猜中了说你太牛了，
超过10次没猜中，返回你太菜了，10次没猜中且告诉他正确答案，
尝试次数为10次
 */
public class GuessGame {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("我已经生成了一个1-100的随机数，请开始猜吧！");


        Random random = new Random();

        //0-99随机生成一个整数
        int randomNumber = random.nextInt(100) + 1;

        //尝试次数初始值为0
        int attempt = 0;

        while (attempt < 10){
            System.out.println("请输入你猜的数字：");
            int guess = sc.nextInt();

            attempt++;

            if (guess < randomNumber){
                System.out.println("你猜小了，猜大点！");
            }else if (guess > randomNumber){
                System.out.println("你猜大了，猜小点！");
            }else {
                System.out.println("你猜对了，你太厉害了！");
                return;
            }
        }

        System.out.println("你猜了10次都没猜对，你有点笨啊！");
        System.out.println("让我来告诉你，正确答案是：" + randomNumber);

    }
}

在这里插入图片描述
8-12提问

1，Java有哪些基本数据类型，对应的包装类型有哪些，为什么需要包装类？

byte	Byte
short	Short
int	integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

因为java的基本数据类型不具备方法去使用，如果想通过基本数据类型的转换，不太方便，所以提供了包装类。

2，Java的访问修饰符及特点

private：私有化，同一个类中可以被调用，不能用来修饰类
default：默认，什么都不用写，在类的同一个包下都可以被调用，可以修饰类，变量，方法
protected：受保护的，在类的同一个包下面都可以调用，可以修饰类，变量，方法
public：公共的。所有位置都可以被调用

3，final关键字的用法

final的意思是最终的，可以用来修饰类，变量，方法
final修饰类，不能被继承
final修饰变量，该变量不能被重新赋值，final修饰的是常量，一般final修饰的变量需要指定初始值
final修饰方法，该方法不能被重写

4，static关键字的用法

static是静态的意思，用来修饰类的方法和变量，被static修饰的变量叫类变量，被static修饰的方法叫类方法，还可以修饰代码块
static修饰变量
（1）static修饰的属性是可以共享的
（2）如果所有对象有一个共同属性值的变量，可将此属性定义为静态的，节约空间
static修饰方法
（1）随着类的加载而加载
（2）只有静态成员变量和静态方法
用static修饰的代码块叫静态代码块