Day5 Java—面向对象3

最新推荐文章于 2024-10-16 10:13:45 发布

C爵

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量61

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_43751390/article/details/122972607

版权

Day 5

1. 所有类通用

构造方法
- 名称与**类名相同**，无返回类型，无返回值
- 用于初始化值
- 在创建对象时被调用的，==一个对象建立，只调用一次==相应构造函数。
普通成员方法
- 名称任意，必须有返回类型
- 用于完成特定功能
- 由创建好的对象调用，可以**调用多次**。

2. Object类

2.1 概念

类层次结构最顶层的基类，所有类都直接或间接的继承自Object类，所以，所有的类都是一个Object（对象）
构造方法Object()
- 构造一个对象，所有子类对象初始化时都会优先调用该方法
成员方法
- int hashCode()
  - 返回对象的哈希码值，该方法通过对象的地址值进行计算，不同对象返回值不同
- Class<?> getClass
  - 返回调用此方法对象的运行时类对象（调用者的字节码文件对象）
- String toString()
  - 返回该对象的字符串表示
- boolean equals()
  - 返回其他某个对象是否与此对象”相等“。默认情况下比较两个对象的引用，建议重写

public class Test {
    public static void main(String[] args) {
        /**
         * Object类
         */
        Object obj1=new Object();
        Object obj2=new Object();

        //不同对象的哈希码数值不同
        int code1=obj1.hashCode();
        int code2=obj2.hashCode();
        //int类型不能在sout中拼接输出，下面是错误的
        //System.out.println(code1+'\n'+code2);
        System.out.println(code1);
        System.out.println(code2);

        //获取调用者的字节码对象，一个类只有一个字节码文件对象
        Class c1=obj1.getClass();
        Class c2=obj2.getClass();
        System.out.println(c1);
        System.out.println(c2);

        //返回该对象的字符串表示形式，默认打印的是地址值
        //地址值的组成：全类名@该对象的哈希码的无符号十六进制形式
        String s1=obj1.toString();
        String s2=obj2.toString();
        System.out.println(s1+'\n'+s2);

        //比较两个对象是否相等，默认比较的是地址值
        //无意义，子类一般都会重写这个方法
        boolean b1=obj1.equals((obj2));
        System.out.println(b1);
    }
}
/**
1163157884
1956725890

class java.lang.Object
class java.lang.Object

java.lang.Object@4554617c
java.lang.Object@74a14482

false
*/

3. JavaBean

开发中通常需要将对象转成字符串形式进行传输，也需要对即将使用的对象进行相等判断，定义标准JavaBean类重写toString和equals方法，如下代码：

public class Student {
    private String name;
    private int id;
    private int score;

    //无参构造
    public Student(){};

    //有参构造
    public Student(String name, int id, int score) {
        this.name = name;
        this.id = id;
        this.score = score;
    }

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

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

    public void setScore(int score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getScore() {
        return score;
    }

    /**
     * toString重写如下
     * @return
     */
    public String toString(){
        return "Student{name:"+name+",id:"+id+",score:"+score+"}";
    }

    /**
     * id相同就判断相同，equals重写如下
     */
//    public boolean equals(Object object){
//        Student s1=(Student)object;
//        return this.id==s1.id;
//    }

    /**
     * 全相同才判断相同，equals重写如下
     */
    public boolean equals(Object o){
        if(this==o){
            return true;
        }
        if(o==null||getClass()!=o.getClass()){
            return false;
        }
        Student s1=(Student)o;
        return id==s1.id&&name==s1.name&&score==s1.score;
    }
}

public class Test {
    public static void main(String[] args) {
        
        //调用有参构造
        Student s1=new Student("zj",1,100);
        Student s2=new Student("zk",2,100);

        System.out.println(s1);
        System.out.println(s2.toString());
        System.out.println(s1.equals(s2));
    }
}
/**
Student{name:zj,id:1,score:100}
Student{name:zk,id:2,score:100}
false
*/

4. Scanner类

扫描器。能够解析字符串（String）和基本数据类型的数据
构造方法
- Scanner(InputStream):构造一个扫描器对象，从指定输入流中获取数据，参数System.in，对应键盘输入
成员方法
- hasNextxxx()：判断是否有下一个输入项，其中xxx可能是任意基本数据类型，返回结果是布尔类型
- nextxxx()：获取下一个输入项
- String nextLine()：获取下一行数据。一换行符作为分隔符
- String next()：获取下一个输入项，以空白字符作为分隔符（如空格，tab，回车等）

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner s1=new Scanner(System.in);
        System.out.println("输入一个整数：");
        //目标输入的类型不匹配：异常InputMismatchException
        //这时可以加入一个判断
        if(s1.hasNextInt()){     //判断输入的是否是一个整数
            int num=s1.nextInt();
            System.out.println("num:"+num);
        }else{
            System.out.println("输入错误");
        }

        System.out.println("请输入一个字符串str3：");
        Scanner s4=new Scanner(System.in);     //注意这里要重新建一个Scanner对象
        String str3=s4.nextLine();             //结束标记是换行符
        System.out.println("str3:"+str3);

        System.out.println("请输入一个字符串str2：");
        String str2=s1.next();    //结束标记是空白字符
        System.out.println("str2:"+str2);
    }
}
/**
输入一个整数：
4
num:4
请输入一个字符串str3：
rewq
str3:rewq
请输入一个字符串str2：
543 fds
str2:543
*/

5. String类

构造方法
- String(byte[])：构造一个String对象，将指定字节数组中的数据转换成字节串
- String(char[])：构造一个String对象，将指定字节数组中的数据转换成字符串

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

        byte[] bys={97,98,99};
        String s1=new String(bys);     //将字节转成ascii编码
        System.out.println("s1:"+s1);

        char[] chs={'h','e','l','l','o'};
        String s2=new String(chs);      //将字节数组转成字符串
        System.out.println("s2:"+s2);
    }
}
/**
s1:abc
s2:hello
*/

成员方法
- boolean equals(String)：判断当前字符串与给定字符串是否相同，区分大小写
- boolean equalsIgnoreCase(String)：判断当前字符串与给定字符串是否相同,不区分大小写
- boolean startsWith(String)：判断是否以给定字符串开头
- boolean isEmpty()：判断字符串是否为空

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

        //String用的多，所以它的new优化了
        //String s1=new String("abc");
        String s1="abc";
        String s2=" ";
        String s3="ABC";
        
        boolean b1=s1.equals(s3);             //判断字符串是否一样,区分大小写
        System.out.println("b1:"+b1);

        boolean b2=s1.equalsIgnoreCase(s3);   //判断字符串是否一样，不区分大小写
        System.out.println("b2:"+b2);

        System.out.println("判断是否以ac开头："+s1.startsWith("ac"));

        System.out.println("判断是不是空字符串："+s2.isEmpty());
    }
}
/**
b1:false
b2:true
判断是否以ac开头：false
判断是不是空字符串：false
*/

获取方法
- int length() ：获取当前字符串的长度
- char charAt(int index) ：获取指定索引位置的字符
- int indexOf(String) ：获取指定字符(串)第一次出现的索引
- int lastIndexOf(String) ：获取指定字符(串)最后一次出现的索引
- String substring(int) ：获取指定索引位置(含)之后的字符串
- String substring(int, int) ：获取从索引start位置(含)起至索引end位置(不含)的字符串
转换方法
- byte[] getBytes() ：将字符串转换成字节数组
- char[] toCharArray() ：将字符串转换成字符数组
- static String valueOf(..) ：将指定类型数据转换成字符
  - String s1 = String.valueOf(123);
  - String s2 = "" + 123; 这种方法比较常用
- String replace(old, new) ：将指定字符(串)替换成新的字符(串）
- String[] split(String) ：切割字符串,返回切割后的字符串数据,原字符串不变
- String trim() ：去掉字符串两端的空白

6. StringBuilder和StringBuffer类

可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder 和 StringBuffer 使用相同的API（Java帮助文档）。
构造方法
- StringBuilder() ：构造一个空的 StringBuilder 容器
- StringBuilder(String) ：构造一个 StringBuilder 容器,并添加指定字符
成员方法
- StringBuilder append(..) ：将任意数据添加到 StringBuilder 容器中
- String toString() ：将当前 StringBuilder 容器转成字符串

public class Test3 {
    public static void main(String[] args) {
        StringBuilder sb1=new StringBuilder("abc");   //创建StringBuilder
        System.out.println("sb1:"+sb1);
        StringBuilder sb2=sb1.append("efg");          //将efg字符串加到abc后面
        System.out.println("sb1:"+sb1);
        System.out.println("sb2:"+sb2);

        String s3=sb2.toString();        //将其改成字符串
        String s4=String.valueOf(sb1);

        System.out.println(s3+"------"+s4);
    }
}
/**
sb1:abc
sb1:abcefg
sb2:abcefg
abcefg------abcefg
*/

7. Date和Calendar类

日期和日历类。用于操作日期相关信息
构造方法
- Date() ：构造一个日期对象，当前系统时间，精确到毫秒
- Date(long) ：构造一个日期对象，时间为自"1970年1月1日00:00:00 GMT"起，至指定参数的毫秒数
成员方法
- long getTime() ：将日期对象转换成对应时间的毫秒值
- static Calendar getInstance() ：根据当前系统时区和语言环境获取日历对象
- int get(int field) ：返回给定日历字段的值
- void set(int field, int value) ：将给定的日历字段设置为指定的值

public class Test3 {
    public static void main(String[] args) {
        Date d1=new Date();
        System.out.println("d1:"+d1);       //当前系统时间，精确到毫秒

        long time=d1.getTime();             //将日期对象转换成对应时间的毫秒值
        System.out.println("time:"+time);
        
        Date d2=new Date(3608862365624L);   //时间从”1970年1月1日00:00:00 GMT“起，至指定参数的毫秒数
        System.out.println(d2);

    }
}

/**
d1:Sat Jan 22 09:05:17 CST 2022
time:1642813517750
Thu May 11 13:46:05 CST 2084
*/

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

        Calendar c1=Calendar.getInstance();   //获取当前系统的年月日
        System.out.println(c1);

        int year =c1.get(Calendar.YEAR);      //返回日历字段的值
        int month=c1.get(Calendar.MONTH);
        int day=c1.get(Calendar.DATE);
        System.out.println(year + "年" + (month + 1) + "月" + day + "日");

        c1.set(2022,1,2);
        int year2=c1.get(Calendar.YEAR);
        int month2=c1.get(Calendar.MONTH);
        int day2=c1.get(Calendar.DATE);
        System.out.println(year2 + "年" + month2 + "月" + day2 + "日");
    }
}

/**
2022年1月22日
2022年1月2日
*/

8. 基本类型的包装类

java中所有基本数据类型都有其对应的引用数据类型
- 如：int对应Integer类（引用数据类型）
- 如：char对应Character类（引用数据类型）
- 其他都是首字母大写（如double—Douuble）
基本数据类型不是对象,所以Java针对基本类型提供了对应的包装类，以对象的形式来使用。
- 装箱：基本类型转包装类型（对象类型）
- 拆箱：包装类型（对象类型）转基本类型
成员方法
- static 基本类型 parseXxx(String) : 将字符串类型的数据转换成对应的基本类型

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

        int a = 10;                       //装箱，将基本数据类型变为引用数据类型
        Integer i1 = new Integer(a);       //拆箱，将引用数据类型变为基本数据类型
        int b = i1.intValue();            //JDK5以后可以自动拆装箱
        Integer i2 = 30;           //装箱
        int c = i2;                //拆箱
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        String s1 = "100";
        int num = Integer.parseInt(s1);     //将字符串转换为整数型
        System.out.println(num+100);
    }
}
/**
10
10
30
200
*/

9. 静态代码块

可以完成页面初始化相关功能
在类加载时加载，只加载一次，所以比主函数先执行

public class Test6 {
    public static void main(String[] args) {
        System.out.println("主函数中代码执行");
    }
    static{
        System.out.println("静态代码块代码执行了");
    }
}

/**
静态代码块代码执行了
主函数中代码执行
*/

10. 内部类

在类的内部再定义一个类
- 普通内部类（定义实例）
  - A.Aclass ac=new A().new Aclass();
- 静态内部类（定义实例）
  - A.AclassStatic aClassStatic =new A.AClassStatic();
- 匿名内部类
  - 在Java中，接口无法直接实例化对象，，可以通过子类实现实例化。在匿名内部类中，代码层面上可以直new接口，，但是本质还是通过子类来实例化对象，只不过是一个没有名称的子类实例，所以称之为匿名内部类