Java实训第五天

最新推荐文章于 2024-07-10 21:37:49 发布

jxr04

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量311

点赞数 9

文章标签： java 开发语言

本文链接：https://blog.csdn.net/jxr04/article/details/135871487

版权

文章介绍了Java中的基本概念，包括Object类的作用、重写equals、hashCode和toString方法，包装类如Integer和BigDecimal的使用，以及日期处理类Date和SimpleDateFormat的示例，还有可变参数的使用方法。

摘要由CSDN通过智能技术生成

一.常用类：

object类：

Java.lang.Object类是Java语言中类层次结构的根类，

即任何一个类都是该类的字节或者间接子类。

package com.java.object01;

public class ObjectDemo01 /*extends Object(隐藏，所有的类都直接或间接的继承与object类)*/{
    public static void main(String[] args) {

    }
}

package com.java.object01;

import java.util.Objects;

public class Student {

    private String name;
    private int id;

    /*
    @Override
    public boolean equals(Object o){

        Student student = (Student)o;
        //将o强转成Stuent类型，并将结果赋值给名为student的Student类型变量。

        return  this.id() == student.id();
    }
    **/

    /*
    @Override
    public boolean equals(Object o){
        return this.id() = ((Student)o).id();
    }
    **/

    /*
    @Override
    public boolean equals(Object o){
        if(this == o){
            return true;
        }
        if (null == o){
            return false;
        }
        if (o instanceof Student){
            Student student = (Student) o;
            if (this.name().equals(Student.name()) && this.id().equals(Student.id())){
            return true;
            }
        }
        retrun true;
    }
    */

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }

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

    public Student() {
    }

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

    public String name() {
        return name;
    }

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

    public int id() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}
/*
*
* 无参有参
* set，get方法
* 重写equals，hashCode，toString方法
* 成员方法
* */

package com.java.object01;

public class StudentTest {
    public static void main(String[] args) {
        //new出的对象引用地址肯定不一样
        Student student1 = new Student("lxp",29);

        System.out.println(student1);//System.out.println(student1。toString（）)；
        //Object中的toString默认的是包名@哈希码值的无符号十六进制表示组成
        // com.java.object01.Student@32ebfa
        //toString重写后 Student{name='lxp', id=29}

        Student student2 = new Student("jxr",49);
        Student student3 = new Student("jxr",49);
        //System.out.println(student1 == student2 );//flase 比较的是两者的地址值
        System.out.println(student2.equals(student3));//flase 默认比较的是两个地址

    }
}
/*
  ==与equals（）区别：
  == ： 基本数据类型  比较的是数值的大小
        引用数据类型  比较的是引用的地址
  equals ： 默认比较的是两对象的地址值，若想比较二者的内容时，需要重写这个方法。

 */

包装类：

通常情况下基本数据类型的变量不是对象，

为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，

负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。

package com.java.packaging01;

/*
* 包装类：
* int ->java.long.Integer;
* char ->java.long.Character
* 其余都是首字母大写
* */

public class PackeagingDemo01 {
    public static void main(String[] args) {//Integer类的常用方法
        Integer it1 = new Integer(10);
        System.out.println("it1=" + it1);

        //将Integer类型的对象，转变为int类型的对象，叫做手动拆箱
        int i = it1.intValue();
        System.out.println();
        System.out.println(i);

        //将int类型的对象，转变为Integer类型的对象，叫做手动装箱
        Integer integer = Integer.valueOf(30);
        System.out.println();
        System.out.println(integer);

        Integer it2 = new Integer("20");//不能有数字以外的
        System.out.println();
        System.out.println("it2=" + it2);

        //JDK1.5开始提供自动装箱和拆箱机制
        Integer i1 = 12;
        int i2 = i1;
        System.out.println();
        System.out.println(i2);

        String str = "123";
        int i3 = Integer.parseInt(str);
        System.out.println();
        System.out.println(i3);


    }
}

数字处理类：

BigDecimal类：

float类型和double类型在运算时可能会有误差。

若想实现精确运输则需借助java.math.BigDecimal类型加以描述。

package com.java.packaging01;
import java.math.BigDecimal;
/*
* 希望实现精确运算
* 则需借助Java，math。BigDecimal类型加以描述
* */

public class BigDecimalTest {
    public static void main(String[] args) {//BigDecimal类的常用方法
        double d1 = 0.1 + 0.2;
        System.out.println(d1);//0.30000000000000004不精确

        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.23");

        System.out.println(bd1.add(bd2)); //bd1 + bd2 0.33
        System.out.println(bd1.subtract(bd2));//bd1 - bd2 -0.13
        System.out.println(bd1.multiply(bd2));//bd1 * bd2 0.023

        //System.out.println(bd1.divide(bd2));
        // 除不尽会提示算数异常
        // no exact representable decimal result(没有精确的可表示的十进制结果)

        System.out.println(bd1.divide(bd2,BigDecimal.ROUND_UP));//"四舍五入" bd1/bd2 0.5
    }
}

String类：

package com.java.packaging01.stringtest;
/*
 * @Author jingxurun
 * @Date 2024/1/26 星期五 15:41
 * @Version
 **/

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

        String str1 = "abc";
        String str2 = "123";
        System.out.println(str1 == str2);//flase 比的是地址值

        String str3 = new String("abc");//new 开了一个新的容器地址值也改变
        String str4 = new String("123");
        System.out.println(str1 == str3);//flase 比的是地址值
        System.out.println(str3 == str4);//flase 比的是地址值

        String str5 = "abc";
        System.out.println(str1 == str5);//true
        /* 常量池（原理）：
         *String类型描述的字符串是个常量不可改变，因此Java虚拟机将首次出现的字符串放入常量中，
         *若后续代码中出现了相同的字符串内容则直接使用池中已有的字符串对象而无需申请内存以及创建对象，
         *从而提高了性能。
         **/

        byte[] brr = {97,98,99,10,101};//字节不是字符串 a,b,c,d,e [ASCII码表]
        String str6 = new String(brr,0,2);//以brr的0到2的字节来构造对象
        System.out.println(str6);//ab

        byte a = 97;
        char c = (char) a;
        System.out.println(c);//a

    }
}

package com.java.packaging01.stringtest;/*
 * @Author jingxurun
 * @Date 2024/1/26 星期五 16:05
 * @Version
 **/

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

        String str = new String(" Let me can can need shy shy ! ");

        System.out.println("第13个字符是" + str.charAt(13));//a
        System.out.println("字符串的长度为" + str.length());//31
        System.out.println("查看是否有“me”字符串：" + str.contains("me"));
        System.out.println(str.toUpperCase());//全部变为大写
        System.out.println(str.toLowerCase());//全部变为小写
        System.out.println(str.trim());//去掉前导和后继的空白字符串
        System.out.println(str.startsWith("Let"));//查看是否为“Let”字符串开头
        System.out.println(str.startsWith("!"));//查看是否为“！”字符串结尾

        String s = new String();
        System.out.println("s = " + s);//空字符串但是不是NULL

        byte[] brr = {99,98,97,96,95};

    }
}

StringBuilder和StringBuffe类：

package com.java.packaging01.stringbuffer;
/*
 * @Author jingxurun
 * @Date 2024/1/26 星期五 17:03
 * @Version
 **/

public class StringBufferDemo01 {
    public static void main(String[] args) {//StringBuilder和StringBuffe类的常用方法（相同）

        StringBuilder sb1 = new StringBuilder();
        System.out.println("初始容量为：" + sb1.capacity());//16
        System.out.println("长度为：" + sb1.length());//0

        StringBuilder sb2 = new StringBuilder("WUWUUWUWUWU");
        System.out.println("初始容量为：" + sb2.capacity());//27
        System.out.println("长度为：" + sb2.capacity());//27

        System.out.println(sb2.insert(0,"wind:"));//插入字符 0的位置 加入 wind:WUWUUWUWUWU
        System.out.println(sb2.append("666"));//追加字符 wind:WUWUUWUWUWU666
        System.out.println(sb2.delete(0,5));//删除字符串，包头不包尾 WUWUUWUWUWU666
        System.out.println(sb2.reverse());//字符串反转 666UWUWUWUUWUW
        System.out.println(sb2.indexOf("666"));//查找字符串出现的位置 0

    }
}

/* String类描述的字符内容是个常量，
  不可改变当需要在Java代码中描述大量类似的字符串时，
  只能单独使用和储存，此时会造成内存空间的浪费。
  为了解决上述问题，
  可以使用Java.lang.StringBuilder类和StringBuffer类来描述字符序列可以改变的字符串，eg:"ab","abc","abcd".
  其中StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低；
  其中StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，因此效率比较高。
**/

日期相关类：（了解）

Date，SimpleDateFormat类：

package com.java.date;
/*
 * @Author jingxurun
 * @Date 2024/1/26 星期五 17:47
 * @Version
 **/
import java.util.Date;
import java.text.SimpleDateFormat;

public class DateDemo01 {

    public static void main(String[] args) {

        Date date = new Date();
       /*
       System.out.println(date);

        Date date1 = new Date(10000);
        System.out.println(date1);

        date1.setTime(1000);
        System.out.println(date1.getDate());
        **/

        SimpleDateFormat simpleTimeZone = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleTimeZone.format(date);
        System.out.println(format);
    }
}

二.可变参数：

package com.java.variadics;/*
 * @Author jingxurun
 * @Date 2024/1/26 星期五 18:03
 * @Version
 **/

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(add(1,2));
    }
   /* public static double add(double a,double b){
        return a + b;
    }*/
     public static double add(double...args){
         // args是可变形参，
         // 只能出现在参数列表的最后。
         // 可传入任意数目的参数
        double sum = 0;
         for (int i = 0; i < args.length; i++) {
             sum += args[i];
         }
         return sum;
         //参数在方法内部 以数组的形式来接收
    }
}