【26天高效学完Java编程】第7天-Java类与对象的介绍及八大经常使用类,帮你一次性总结好 (超详细教程,附源码、图片示例)

2022年05月14日 阅读数:5
这篇文章主要向大家介绍【26天高效学完Java编程】第7天-Java类与对象的介绍及八大经常使用类,帮你一次性总结好 (超详细教程,附源码、图片示例),主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

本专栏将从基础开始,按部就班,由浅入深讲解Java的基本使用,但愿你们都可以从中有所收获,也请你们多多支持。
专栏地址:26天高效学习Java编程
相关软件地址:软件地址
全部代码地址:代码地址
若是文章知识点有错误的地方,请指正!你们一块儿学习,一块儿进步。
若是感受博主的文章还不错的话,还请关注、点赞、收藏三连支持一下博主哦html

1. 类和对象

1.1 类和对象的理解

客观存在的事物皆为对象 ,因此咱们也经常说万物皆对象。java

    • 类的理解
      • 类是对现实生活中一类具备共同属性和行为的事物的抽象
      • 类是对象的数据类型,类是具备相同属性和行为的一组对象的集合
      • 简单理解:类就是对现实事物的一种描述
    • 类的组成
      • 属性:指事物的特征,例如:手机事物(品牌,价格,尺寸)
      • 行为:指事物能执行的操做,例如:手机事物(打电话,发短信)
  • 类和对象的关系
    • 类:类是对现实生活中一类具备共同属性和行为的事物的抽象
    • 对象:是可以看获得摸的着的真实存在的实体
    • 简单理解:类是对事物的一种描述,对象则为具体存在的事物

1.2 类的定义

类的组成是由属性和行为两部分组成git

  • 属性:在类中经过成员变量来体现(类中方法外的变量)
  • 行为:在类中经过成员方法来体现(和前面的方法相比去掉static关键字便可)

类的定义步骤:web

①定义类面试

②编写类的成员变量算法

③编写类的成员方法编程

public class 类名 {
   
   
	// 成员变量
	变量1的数据类型 变量1;
	变量2的数据类型 变量2;// 成员方法
	方法1;
	方法2;	
}

示例代码:数组

/*
    手机类:
        类名:
        手机(Phone)

        成员变量:
        品牌(brand)
        价格(price)

        成员方法:
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
   
   
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
   
   
        System.out.println("打电话");
    }

    public void sendMessage() {
   
   
        System.out.println("发短信");
    }
}

1.3 对象的使用

  • 建立对象的格式:
    • 类名 对象名 = new 类名();
  • 调用成员的格式:
    • 对象名.成员变量
    • 对象名.成员方法();
  • 示例代码
/*
    建立对象
        格式:类名 对象名 = new 类名();
        范例:Phone p = new Phone();

    使用对象
        1:使用成员变量
            格式:对象名.变量名
            范例:p.brand
        2:使用成员方法
            格式:对象名.方法名()
            范例:p.call()
 */
public class PhoneDemo {
   
   
    public static void main(String[] args) {
   
   
        //建立对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

1.4 学生对象-练习

  • 需求:首先定义一个学生类,而后定义一个学生测试类,在学生测试类中经过对象完成成员变量和成员方法的使用
  • 分析:
    • 成员变量:姓名,年龄…
    • 成员方法:学习,作做业…
  • 示例代码:
![1](C:\TeachRes\Java2019\JavaSe01\day07\4-笔记\笔记图片资源包\1.png)class Student {
   
   
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
   
   
        System.out.println("好好学习,每天向上");
    }

    public void doHomework() {
   
   
        System.out.println("键盘敲烂,月薪过万");
    }
}
/*
    学生测试类
 */
public class StudentDemo {
   
   
    public static void main(String[] args) {
   
   
        //建立对象
        Student s = new Student();

        //使用对象
        System.out.println(s.name + "," + s.age);

        s.name = "林青霞";
        s.age = 30;

        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();
    }
}

2. 对象内存图

2.1 单个对象内存图

  • 成员变量使用过程

1

  • 成员方法调用过程

2

2.2 多个对象内存图

  • 成员变量使用过程

3

  • 成员方法调用过程

4

  • 总结:安全

    多个对象在堆内存中,都有不一样的内存划分,成员变量存储在各自的内存区域中,成员方法多个对象共用的一份app

2.3 多个对象指向相同内存图

4

  • 总结

    当多个对象的引用指向同一个内存空间(变量所记录的地址值是同样的)

    只要有任何一个对象修改了内存中的数据,随后,不管使用哪个对象进行数据获取,都是修改后的数据。

3. 成员变量和局部变量

3.1 成员变量和局部变量的区别

  • 类中位置不一样:成员变量(类中方法外)局部变量(方法内部或方法声明上)
  • 内存中位置不一样:成员变量(堆内存)局部变量(栈内存)
  • 生命周期不一样:成员变量(随着对象的存在而存在,随着对象的消失而消失)局部变量(随着方法的调用而存在,醉着方法的调用完毕而消失)
  • 初始化值不一样:成员变量(有默认初始化值)局部变量(没有默认初始化值,必须先定义,赋值才能使用)

4. 封装

4.1 private关键字

private是一个修饰符,能够用来修饰成员(成员变量,成员方法)

  • 被private修饰的成员,只能在本类进行访问,针对private修饰的成员变量,若是须要被其余类使用,提供相应的操做
    • 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰
    • 提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰
  • 示例代码:

    /*
        学生类
     */
    class Student {
         
         
        //成员变量
        String name;
        private int age;
    
        //提供get/set方法
        public void setAge(int a) {
         
         
            if(a<0 || a>120) {
         
         
                System.out.println("你给的年龄有误");
            } else {
         
         
                age = a;
            }
        }
    
        public int getAge() {
         
         
            return age;
        }
    
        //成员方法
        public void show() {
         
         
            System.out.println(name + "," + age);
        }
    }
    /*
        学生测试类
     */
    public class StudentDemo {
         
         
        public static void main(String[] args) {
         
         
            //建立对象
            Student s = new Student();
            //给成员变量赋值
            s.name = "林青霞";
            s.setAge(30);
            //调用show方法
            s.show();
        }
    }
    

4.2 private的使用

  • 需求:定义标准的学生类,要求name和age使用private修饰,并提供set和get方法以及便于显示数据的show方法,测试类中建立对象并使用,最终控制台输出 林青霞,30

  • 示例代码:

    /*
        学生类
     */
    class Student {
         
         
        //成员变量
        private String name;
        private int age;
    
        //get/set方法
        public void setName(String n) {
         
         
            name = n;
        }
    
        public String getName() {
         
         
            return name;
        }
    
        public void setAge(int a) {
         
         
            age = a;
        }
    
        public int getAge() {
         
         
            return age;
        }
    
        public void show() {
         
         
            System.out.println(name + "," + age);
        }
    }
    /*
        学生测试类
     */
    public class StudentDemo {
         
         
        public static void main(String[] args) {
         
         
            //建立对象
            Student s = new Student();
    
            //使用set方法给成员变量赋值
            s.setName("林青霞");
            s.setAge(30);
    
            s.show();
    
            //使用get方法获取成员变量的值
            System.out.println(s.getName() + "---" + s.getAge());
            System.out.println(s.getName() + "," + s.getAge());
    
        }
    }
    

4.3 this关键字

  • this修饰的变量用于指代成员变量,其主要做用是(区分局部变量和成员变量的重名问题)

    • 方法的形参若是与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
    • 方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量
public class Student {
   
   
    private String name;
    private int age;

    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 void show() {
   
   
        System.out.println(name + "," + age);
    }
}

4.4 this内存原理

  • this表明当前调用方法的引用,哪一个对象调用的方法,this就表明哪个对象

  • 示例代码:

    public class StudentDemo {
         
         
        public static void main(String[] args) {
         
         
            Student s1 = new Student();
            s1.setName("林青霞");
            Student s2 = new Student();
            s2.setName("张曼玉");
        }
    }
    
  • 图解:

    5

    6

4.5 封装思想

  1. 封装概述
    是面向对象三大特征之一(封装,继承,多态)
    是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是没法直接操做的
  2. 封装原则
    将类的某些信息隐藏在类内部,不容许外部程序直接访问,而是经过该类提供的方法来实现对隐藏信息的操做和访问
    成员变量private,提供对应的getXxx()/setXxx()方法
  3. 封装好处
    经过方法来控制成员变量的操做,提升了代码的安全性
    把代码用方法进行封装,提升了代码的复用性

5. 构造方法

5.1 构造方法概述

构造方法是一种特殊的方法

  • 做用:建立对象 Student stu = new Student();

  • 格式:

    public class 类名{

    ​ 修饰符 类名( 参数 ) {

    ​ }

    }

  • 功能:主要是完成对象数据的初始化

  • 示例代码:
class Student {
   
   
    private String name;
    private int age;

    //构造方法
    public Student() {
   
   
        System.out.println("无参构造方法");
    }

    public void show() {
   
   
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
   
   
    public static void main(String[] args) {
   
   
        //建立对象
        Student s = new Student();
        s.show();
    }
}

5.2 构造方法的注意事项

  • 构造方法的建立

若是没有定义构造方法,系统将给出一个默认的无参数构造方法
若是定义了构造方法,系统将再也不提供默认的构造方法

  • 构造方法的重载

若是自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法

  • 推荐的使用方式

不管是否使用,都手工书写无参数构造方法

  • 重要功能!

可使用带参构造,为成员变量进行初始化

  • 示例代码
/*
    学生类
 */
class Student {
   
   
    private String name;
    private int age;

    public Student() {
   
   }

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

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

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

    public void show() {
   
   
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
   
   
    public static void main(String[] args) {
   
   
        //建立对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

5.3 标准类制做

①类名须要见名知意

②成员变量使用private修饰

③提供至少两个构造方法

  • 无参构造方法

  • 带所有参数的构造方法

④成员方法

  • 提供每个成员变量对应的setXxx()/getXxx()

  • 若是还有其余行为,也须要写上

6.练习1-定义学生类

需求:

​ 定义标准学生类,要求分别使用空参和有参构造方法建立对象,空参建立的对象经过setXxx赋值,有参建立的对象直接赋值,并经过show方法展现数据。

示例代码:

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

    //构造方法
    public Student() {
   
   
    }

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

    //成员方法
    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 void show() {
   
   
        System.out.println(name + "," + age);
    }
}
/*
    建立对象并为其成员变量赋值的两种方式
        1:无参构造方法建立对象后使用setXxx()赋值
        2:使用带参构造方法直接建立带有属性值的对象
*/
public class StudentDemo {
   
   
    public static void main(String[] args) {
   
   
        //无参构造方法建立对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //使用带参构造方法直接建立带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

7.练习2-建立对象并添加到数组

需求:

​ 定义一个标准的javabean类
​ Student学生类
​ 属性:name,age
​ 在测试类中,建立两个学生对象并添加到数组中。

代码示例:

public class Test {
   
   
    public static void main(String[] args) {
   
   
        //需求:
        //定义一个标准的javabean类
        //Student学生类
        //属性:name,age
        //在测试类中,建立两个学生对象
        Student s1 = new Student();
        s1.setName("zhangsan");
        s1.setAge(23);

        Student s2 = new Student("lisi", 24);

        //建立一个长度为2的数组,用来存储学生对象
        Student[] arr = new Student[2];

        //把学生对象添加到数组当中
        arr[0] = s1;
        arr[1] = s2;

        //遍历数组,打印两个学生对象的全部信息
        for (int i = 0; i < arr.length; i++) {
   
   
            //i 索引   arr[i] 元素(学生对象)
            Student stu = arr[i];
            System.out.println(stu.getName() + ", " + stu.getAge());
        }

    }
}


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

    //空参构造
    //带所有参数的构造
    //针对于每个私有化的成员变量都要提供对有的get和set方法
    public Student() {
   
   
    }

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

    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;
    }
}

8.练习3-修改年龄

需求:

​ 定义javabean类,要求以下:

​ 学生类(属性:姓名、年龄)

​ 在测试类中,建立5个学生对象并添加到数组中

​ 再遍历数组,若是学生的年龄小于18岁,那么就在原有基础上+2岁

​ 最后遍历数组

代码示例:

public class Test {
   
   
    public static void main(String[] args) {
   
   
        //1.需求:
        //定义javabean类(Student)
        //属性:姓名,年龄
        //2.定义五个学生对象,
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",15);
        Student s3 = new Student("wangwu",17);
        Student s4 = new Student("zhaoliu",21);
        Student s5 = new Student("qianqi",22);
        //3.添加到数组当中
        Student[] arr = new Student[5];
        arr[0] = s1;
        arr[1] = s2;
        arr[2] = s3;
        arr[3] = s4;
        arr[4] = s5;
        //4.若是学生的年龄小于18岁,那么就在原有的基础上+2岁。
        for (int i = 0; i < arr.length; i++) {
   
   
            //i 索引 arr[i] 元素(学生对象)
            Student stu = arr[i];
            int age = stu.getAge();
            if(age < 18){
   
   
                //若是小于18,咱们就要在原有的基础上+2
                //age + 2;
                stu.setAge(age + 2);
            }
        }
        //5.遍历数组
        for (int i = 0; i < arr.length; i++) {
   
   
            Student stu = arr[i];
            System.out.println(stu.getName() +", " + stu.getAge());
        }
    }
}


package com.itheima.demo9;

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

    public Student() {
   
   
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
   
   
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
   
   
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
   
   
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
   
   
        this.age = age;
    }

}

9.快速生成javabean的方式

记得必定要先手写,javabean类里面有不少细节须要咱们注意的。

若是手写不出错了,能够用快捷键,使用方式以下:

1,先定义javabean中的属性

2,在javabean类的空白处,按快捷键:

​ alt + Insert 或者 alt + Fn + Insert

3,选择第一个,生成构造方法

4,选择get and set 生成get和set方法

若是快捷键练熟了,可使用PTG插件。

在setting里面搜索PTG,下载并安装便可

10.八大Java经常使用类

Java的经常使用类哟以下几种:

image-20220510090922999

下面分别介绍一下这些经常使用类:

10.1 字符串类

字符串类经常使用方法速查表以下:

修饰符和返回值的类型 方法名 解释
char charAt() 获取某个位置的字符
String concat() 字符串的拼接。通常字符串拼接直接相加就行了
boolean contains() 判断原字符串是否含有某个字符串,经常使用于子串的判断
boolean endsWith() 判断原字符串是否以某个字符串结尾
boolean startsWith() 判断原字符串是否以某个字符串开头
boolean equals() 判断两边字符串内容是否相同;==判断地址是否相同
boolean equalsIgnoreCase() 忽略大小写判断两边字符串的内容是否同样
int indexOf() 计算给出字符串第一个出现的位置
int LastindexOf() 计算给出字符串最后一个出现的位置
int length() 计算字符串的长度
String replace() 字符串内容的替换
String[] split() 字符串切割,最终结果是一个字符串数组
String substring() 字符串截取,左闭右开:[ )
String trim() 去掉字符串左右两边的空格,中间的不行
static String valueOf() 官方:基本数据类型转为字符串操做;直接:变量 + “”

注:字符串是一个不可变的类型(final类),几乎全部的字符串操做都会返回一个新字符串而不是在原有基础上进行修改。

代码演示以下:

public class Test {
   
   
    public static void main(String[] args) {
   
   
        String s = "个人名字叫天天都要努力的小颓废呀";
        
        s.concat("hhh"); // 在字符串s上拼接,拼接hhh
        System.out.println(s);// 个人名字叫李华
        //字符串是不可变的数据类型
        //几乎全部的字符串操做都会返回一个新字符串
        String s1 = s.concat("hhh"); // 在字符串s上拼接,拼接hhh
        System.out.println(s1);//个人名字叫天天都要努力的小颓废呀hhh
        
       
        s.replace("absdf","卷王");
        System.out.println(str3); //个人名字叫天天都要努力的小颓废呀  并无替换 字符串是不变的str1仍是str1

        String str2 = str1.replace("小颓废","卷王");//几乎全部的字符串操做都会返回一个新字符串 新串要用新变量接
        System.out.println(str2);//个人名字叫卷王呀
         
   }
}

package String;

import java.util.Scanner;

public class Test {
   
   
    public static void main(String[] args) {
   
   
        String s = "个人名字叫小颓废";
        System.out.println(s.charAt(0)); // 获取第0个位置的字符

        s.concat("hhh");
        System.out.println(s);// 个人名字叫小颓废
        //字符串是不可变的数据类型
        //几乎全部的字符串操做都会返回一个新字符串
        String s1 = s.concat("hhh"); // 在字符串s上拼接,拼接hhh
        System.out.println(s1);//个人名字叫小颓废hhh

        System.out.println(s.contains("李华")); //true
        System.out.println(s.contains("牛津")); //false

        System.out.println("邀请小颓废来参加csdn嘉年华活动".endsWith("活动"));//true 判断是否以xxx为结尾
        System.out.println("邀请小颓废来参加csdn嘉年华活动".startsWith("小颓废"));//false 判断是否以xxx开头

        // equals字符串内容是否相同

        // 接受邀请参加活动的李华到现场后要输入验证码
//        String yanZhengMa = "AAkm";
//
//        Scanner sc = new Scanner(System.in);
//
//        System.out.println("请输入验证码("+yanZhengMa+")");
//
//        String userInput = sc.nextLine();
//
//        if(yanZhengMa.equalsIgnoreCase("aakm")){  // 忽略大小写判断两边的内容是否同样
//            System.out.println("欢迎参加csdn嘉年华活动!");
//        }else{
   
   
//            System.out.println("您未受到邀请,请现场报名!");
//        }

//        String str = "小颓废玩得很开心!";
//        System.out.println(str.indexOf("开心"));// 5 计算给出字符串第一个出现的位置

        String str2 = "小颓废成绩很好";
        System.out.println(str2.length()); // 7 计算字符串的长度

        String str3 = "小颓废喜欢看罗老师的视频";
        str3.replace("小颓废","张三");
        System.out.println(str3); //小颓废喜欢看罗老师的视频  并无替换 字符串是不变的str3仍是str3

        String str4 = str3.replace("小颓废","张三");//几乎全部的字符串操做都会返回一个新字符串 新串要用新变量接
        System.out.println(str4);//张三喜欢看罗老师的视频

        String str5 = "哈哈_呵呵_嘻嘻_噢no";
        String[] ss = str5.split("_");//切割
        System.out.println(ss[0]);//哈哈
        System.out.println(ss[1]);//哈哈
        System.out.println(ss[2]);//嘻嘻
        System.out.println(ss[3]);//噢no

        String str6 = "今每天气不错";
        System.out.println(str6.substring(2,4));//天气 字符串截取 [ ) 左闭右开,右边取不到

        String str7 ="     哈    哈      ";
        System.out.println(str7.trim());// 去掉左右两边的空格

        int i = 10;
        System.out.println(String.valueOf(i)); // 基本数据类型转为字符串
        System.out.println(i+""); // 把数字转为字符串


    }
}

10.2 StringBuilder和StringBuffer类

String 是一个不可变的数据类型,放在常量区,每次拼接都会产生一个新的字符串,那么内存早晚会被这些拼接的字符串塞满。为了解决这个问题,出现了StringBuilder和StringBuffer类。

String类和StringBuilder和StringBuffer类的区别:

StringBuilder和StringBuffer:可变的字符串,不产生新对象,比较省内存,当进行大量的字符串拼接时建议使用StringBuffer和StringBuilder,但它们两个一些方法的实现几乎跟String同样。

StringBuffer和StringBuilder类:

【类似点】

二者用法如出一辙,能够认为是一个类

【区别】

  1. StringBuilder非线程安全,StringBuffer线程安全。
  2. StringBuilder相比于StringBuffer有速度优点,多数状况下建议使用StringBuilder类,但当被要求线程安全时必须使用StringBuilder类
//字符串拼接的方式以下:append()方法
//StringBuffer和StringBuilder 转成String类 :
StringBuilder sb = new StringBuilder("猫喜欢吃鱼");
String s = sb.toString();		

参考代码:

package String;

public class TestStringBuilder {
   
   
    public static void main(String[] args) {
   
   
        StringBuilder sb = new StringBuilder();// 一个空的字符串""

        StringBuilder sb2 = new StringBuilder("猫喜欢吃鱼");
        System.out.println(sb2);// 猫喜欢吃鱼

        sb2.append(",狗也喜欢吃鱼");
        System.out.println(sb2);// 追加  猫喜欢吃鱼,狗也喜欢吃鱼

        sb2.insert(1,"哈哈哈");
        System.out.println(sb2); //猫哈哈哈喜欢吃鱼,狗也喜欢吃鱼

        // 上述的操做huan'c

        // 把StringBuilder转化成String
        String s = sb2.toString();
        System.out.println(s); //猫哈哈哈喜欢吃鱼,狗也喜欢吃鱼

        // 上述操做均可以将StringBuilder换成StringBuffer,结果同样

    }
}

10.3 Object类

Object的常见方法以下图所示:

图片

下面介绍一下关于Object类面试中常见的问题:

==和equals区别

==是一个比较运算符

  1. ==:既能够判断基本类型,又能够判断引用类型

  2. ==:若是判断的是基本类型,判断的是值是否相等。

//==: 若是判断的是基本类型,判断的是 值 是否相等
        int x1 = 10;
        int x2 = 10;
        double x3 = 10.0;
        System.out.println(x1 == x2);//true
        System.out.println(x1 == x3);//true
  1. ==:若是判断的是引用类型判断的是地址是否相等,即判断是否是同一个对象
package Equals;

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        //==: 若是判断的是引用类型,判断的是地址是否相等,即判断是否是同一个对象
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a==c);// ? true
        System.out.println(b==c);// true

        B obj = a;
        System.out.println(obj==c);// true

    }
}

class B{
    
    }
class A extends B{
    
    }

图片

  1. equals方法是Object类中的方法,只能判断引用类型

  2. equals默认判断的是地址是否相等,子类(Object类是全部类的父类)每每重写该方法,用于判断内容是否相等

//Object类 equals()方法原码

//默认判断地址是否同样
    public boolean equals(Object obj) {
    
    
        return (this == obj);
    }
    
子类每每重写该方法,用于判断内容是否相等  String类中的equals()方法原码(重写了父类equals()方法)
  
    public boolean equals(Object anObject) {
    
    
        if (this == anObject) {
    
     // 若是是同一个对象(地址相同)
            return true; // 返回true
        }
        if (anObject instanceof String) {
    
     // 判断类型
            String anotherString = (String)anObject; // 向下转型
            int n = value.length;
            if (n == anotherString.value.length) {
    
     // 若是长度相同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
    
     // 比较每个字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true; // 若是两个字符串每个字符都相同,则返回true
            }
        }
        return false;
    }

 

再看个例子

image-20220510095424766

【小练习】

写出输出结果:

package Equals;

public class EqualsTest01 {
   
   
    public static void main(String[] args) {
   
   
        Person p1 = new Person();
        p1.name = "tom";
        Person p2 = new Person();
        p2.name = "tom";

        System.out.println(p1 == p2);// 引用类型——判断是否为同一个对象(地址)
        System.out.println(p1.name.equals(p2.name));// p.name是String类型,重写了equals()方法——判断内容是否同样
        System.out.println(p1.equals(p2));//p1,p2属于Person类,该类并无重写equals()方法(继承父类equals()方法,即判断地址)

        String s1 = new String("abc");
        String s2 = new String("abc");

        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);

    }
}

class Person{
   
   
    public String name;
}

输出结果:

false
true
false
true
false

hashCode方法

image-20220510095530358

小总结:(能够看成地址来看但它本质上不是地址

  1. 提升具备哈希结构的容器的效率
  2. 两个引用,若是指向的是同一个对象,则哈希值确定同样
  3. 两个引用,若是指向的是不一样对象,则哈希值是不同的
  4. 哈希值主要根据地址号来!不能将哈希值彻底等价于地址
  5. 在后面的集合中hashCode若是须要的话,也会重写
package hashCode;

public class HashCode {
   
   
    public static void main(String[] args) {
   
   
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode()="+ aa.hashCode());
        System.out.println("aa2.hashCode()="+ aa2.hashCode());
        System.out.println("aa3.hashCode()="+ aa3.hashCode());
    }
}

class AA{
   
   }

输出结果:

aa.hashCode()=460141958
aa2.hashCode()=1163157884
aa3.hashCode()=460141958

toString方法

image-20220510095603558

基本介绍:

默认返回:全类名 + @ + 哈希值的十六进制

/*
    Object toString()原码
    //(1)getClass().getName() 类的全类名(包名+类名)
    //(2)Integer.toHexString(hashCode()) 将hashCode的值转成16进制字符串
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 */

示例以下:

image-20220510095638295

子类每每重写toString方法,用于返回对象的属性信息(快捷键:alt + insert),固然咱们也能够本身定制。

当咱们输出一个对象时,toString()方法会被默认调用

image-20220510095734011

当咱们输出一个对象时,toString()方法会被默认调用

image-20220510095823414

finzlize方法(不经常使用)

image-20220510095840963

finzlize方法:当垃圾收集肯定再也不有对该对象的引用时,垃圾收集器在对象上调用该对象。

  1. 当对象被回收时,系统自动调用该对象的finzlize方法。子类能够重写该方法,作一些释放资源的操做
  2. 何时被回收:当某个对象没有任何引用时,则jvm就认为这个对象是一个垃圾对象,就会时候垃圾回收机制来销毁该对象,在销毁该对象前,会先调用finzlize方法。
    在这里插入图片描述>
    垃圾回收机制的调用,是由系统来决定(即有本身的GC算法),也能够经过System.gc()主动触发垃圾回收机制。

在实际开发中,几乎不会用finzlize方法,更多的是为了应付面试

10.4 包装类

1.基本数据类型以及对应的包装类对应关系以下:
byte -> Byte

short -> Short

int -> Integer

long -> Long

float -> Float

double -> Double

char -> Character

boolean -> Boolean

这些类都在java.lang包

2.包装类的意义:
让基本数据类型有面向对象的特征

封装了字符串转化成基本数据类型的方法(重点)

3.包装类经常使用方法:
Integer.parseInt()

Long.paseLong()

Double.parseDouble()

代码示例

public class Test {
   
   
    public static void main(String[] args) {
   
   
        
//        Integer i = new Integer(10);// 建立包装类对象
//        Integer ii = 10; // 自动打包
//        System.out.println(i+10); // 在使用上,int 和Integer 其实没有区别,能够互相使用
//        System.out.println(ii+10);
//        int j = ii;// 自动解包
//        System.out.println(j+100);

        String a = "12";
        String b = "34";
        System.out.println(a+b); // 1234
    // 转型:
        // 字符串转成int的惟一方案
        int c = Integer.parseInt(a);
        int d = Integer.parseInt(b);
        System.out.println(c+d); // 46
        
        // 字符串转成double类型
        String e = "1.25";
        double f = Double.parseDouble(e);
        System.out.println(f*6); // 7.5

        // 转成long类型
        long l = Long.parseLong("1234567");
        System.out.println(l);
    }
}

10.5 DecimalFormat类

DecimalFormat:对小数进行格式化,保留几位小数。

. 表示小数点

0和# 表示数位,保留几位就几个0或者#

参考代码:

import java.text.DecimalFormat;
import java.util.Scanner;

public class Test {
   
   
    public static void main(String[] args) {
   
   
        double d= 10/3.0;
        System.out.println(d);//3.3333333333333335
        
        // . 表示小数点
        // 0和#表示数字

        // 保留两位小数                        格式
        DecimalFormat df = new DecimalFormat(".00"); // 或者.##
        String s = df.format(d); // 把 d 转成上面设置的格式
        System.out.println(s);//3.33

   }
}

10.6 数学类

数学类的方法都是静态方法,能够直接引用——Math.方法();

经常使用数学类方法:

  1. abs():获取绝对值
  2. max():求最大值
  3. min():求最小值
  4. pow():求次幂
  5. round():四舍五入
  6. sqrt():求平方根

10.7 时间类

Java经常使用时间类:

  1. Date 日期类

  2. Calendar 日历类

  3. SimpleDateFormat 格式化时间类

Date和Calendar类 在java.util包中

SimpleDateFormat类 在java.text包

Date 日期

【1】new Date() 能够获取到系统时间

【2】getTime() 能获取到时间的long形式,能够用来计算时间差

getTime()——获取计算机底层存储的数字,返回一个数字用来表示时间,这个数字的类型long,单位为毫秒。

代码参考

import java.util.Date;

public class Test {
   
   
    public static void main(String[] args) {
   
   
        Date d = new Date();
        System.out.println(d); // 系统时间
        //get...()——获取年月日.....
        System.out.println(d.getYear()+1900); // 从1900年开始算的
        System.out.println(d.getMonth()+1); // 月份从0开始计算
        System.out.println(d.getDate()); // 天数
        System.out.println(d.getHours());// 小时

        //getTime()——获取到时间的毫秒形式 返回的是long
        System.out.println(d.getTime());
    }
}

Calendar 日历

【1】get() 获取到时间的某一部分

【2】set() 设置时间 - -> 计算时间:系统已经帮咱们设置好了,不用担忧二月有多少天等问题,计算时间十分方便

注:Calendar 日历类是抽象类,所以不能够去new对象。虽然抽象类不能建立对象,可是jdk官方提供了一个实例对象的操做:

Calendar rightNow = Calendar.getInstance();

咱们经过这条代码就是直接造了一个Calender的对象

【参考代码】:get() 获取到时间的某一部分:

package date;

import java.util.Calendar;

public class TestCalendar {
   
   
    public static void main(String[] args) {
   
   
        Calendar cal = Calendar.getInstance();
//        System.out.println(cal);
        
        /*
 假设当天:
        2022
        5
        10
         */
  cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 计算时间(这里用天数计算的) 
        
        // 获取Calendar建立的对象里的全部内容
        System.out.println(cal.get(Calendar.YEAR)); //  年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份
        System.out.println(cal.get(Calendar.DATE)); // 日
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小时
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
    }
}

【参考代码】:set() 设置时间 - -> 计算时间:

注:cal.setTime(d); 把Date转化成Calendar

package date;

import java.util.Calendar;
import java.util.Date;

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

        Date d = new Date();

        Calendar cal = Calendar.getInstance();

        cal.setTime(d);// 把Date转化成Calendar

        System.out.println(cal);
        System.out.println(cal.get(Calendar.YEAR)); //  年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份:从0开始的
        System.out.println(cal.get(Calendar.DATE)); // 日
        
    }
}


SimpleDateFormat格式化时间

Date,Calendar经过引用也能够进行时间的格式化,但比较繁琐,而SimpleDateFormat类是专门帮咱们格式化时间的工具类,它在java.text包中。

【时间格式】:yyyy-MM-dd HH:mm:ss

SimpleDateFormat类有两大经常使用方法:

【1】format(Date):

format(Date) 帮咱们把时间转成字符串,字符串的格式为SimpleDateFormat类定义对象时设置的时间格式

参考代码:

package Simple;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

public class Test {
   
   
    public static void main(String[] args) {
   
   
        Date d = new Date();
        System.out.println(d); //Thu Aug 12 08:40:08 CST 2021  不美观

  //                  设置格式化时间的模式,咱们经常使用yyyy-MM-dd HH:mm:ss这个模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 时间格式
        String s = sdf.format(d); // 格式化时间
        System.out.println(s); // 2021-08-12 08:45:09
    }
}

【2】parse(String):

parse(String) 帮咱们把字符串转化成时间

参考代码:

package Simple;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个时间(yyyy-MM-dd HH:mm:ss):");

        String s = sc.nextLine();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

       Date d =  sdf.parse(s); // 把字符串转成时间

        System.out.println(d);
        
    }
}

注:因为用户输入的字符串不必定是咱们要求的格式,多是任何东西,想把它们转成时间是不可能的,你不可能把一我的转成时间 对吧,所以存在着很大的风险未处理(异常: java.text.ParseException),为此咱们须要处理异常。

计算时间差

计算思路:

  1. 格式化时间
  2. 先将字符串转化成long类型时间
  3. 计算毫秒级别时间差,取绝对值
  4. 毫秒级别时间差转成秒级别
  5. 秒级别时间差转成分钟级别
  6. 分钟级别时间差转化显示成xx小时xx分钟

参考代码:

package Simple;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDiff {
   
   
    public static void main(String[] args) throws ParseException {
   
   

        String s1 = "2021-05-20 12:00:00"; // 开始时间
        String s2 = "2022-5-10 14:35:00"; // 结束时间

        //格式化时间
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");

        //将字符串转成时间形式
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        //计算时间差:先要获取时间毫秒形式(long类型) 再作差
        long long1 = d1.getTime();
        long long2 = d2.getTime();
        long diffTime = Math.abs(long1 - long2);

        // 秒级别时间差
        long diffSec = diffTime / 1000;

        // 分级别时间差
        long diffMin = diffSec / 60;

        //显示 xx小时xx分钟
        long displayHours = diffMin / 60; // 小时
        long displayMin = diffMin % 60; //分钟

        System.out.println("您学习的时长为:"+displayHours+"小时"+displayMin+"分钟");

    }
}

10.8 内部类

概念:在一个类内部再定义一个完整的类。

通常状况下类与类之间是相互独立的,内部类的意思就是打破这种独立思想,让一个类成为另外一个类的内部信息,和成员变量、成员方法同等级别。

内部类的好处:

把一个类写在外面和写在里面最终达到的结果都同样,那咱们为何还要使用内部类,岂不是画蛇添足吗?

采用内部类这种技术,能够隐藏细节和内部结构,封装性更好,让程序的结构更加合理!若是类不少且都暴露在外面,那么类与类之间的调用就会十分繁琐!

内部类的分类:

1.成员内部类(非静态内部类)

参考代码

package NeiBuLei;

public class OuterClass {
   
   
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
   
   
        System.out.println("这是外部类方法!");
        System.out.println(OuterName);
    }
    //内部类
    public class InnerClass{
   
   
        //成员变量
        private String InnerNme;
        //构造方法
        public InnerClass() {
   
   
            InnerNme = "Inner Class";
        }
        //成员方法
        public void display(){
   
   
            System.out.println("这是内部类方法!");
            System.out.println(InnerNme);
        }
    }
    // 主方法
    public static void main(String[] args) {
   
   
        OuterClass outerClass = new OuterClass();
        outerClass.display();//这是外部类方法!null

        // 这个类是内部类,已经不是独立的类了,所以不能像外部类同样直接建立!
        //InnerClass innerClass = new InnerClass(); 行不通
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员方法/变量 只是加了个前缀
        innerClass.display();// 这是内部类方法!
    }

}

输出结果

这是外部类方法!
null
这是内部类方法!
Inner Class

总结:成员内部类(非静态内部类)的使用就是将内部类做为外部类的的一个成员变量/成员方法来使用,因此必须依赖于外部类的对象才能调用,用法和成员变量/成员方法一致!

2.局部内部类

局部内部类:基本的内部类还能够在一个方法体中定义。

package NeiBuLei;

public class OuterClass {
   
   
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
   
   
        class InnerClass {
   
   
            public void print(){
   
   
                System.out.println("这是一个局部内部类方法!");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    // 主方法
    public static void main(String[] args) {
   
   
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

3.静态内部类

静态内部类的构造不须要依赖于外部类对象,类中的静态组件都不须要依赖于任何对象,能够直接经过类自己进行构造。

package NeiBuLei;

public class OuterClass {
   
   
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
   
   
        System.out.println("这是外部类方法!");
        System.out.println(OuterName);
    }
    //静态内部类
    public static class InnerClass{
   
   
        private String InnerName;

        public InnerClass() {
   
   
            InnerName = "Inner Class";
        }

        //成员方法
        public void display(){
   
   
            System.out.println("这是静态内部类方法!");
            System.out.println(InnerName);
        }
    }

    // 主方法
    public static void main(String[] args) {
   
   
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 静态内部类的构造不依赖与外部类,能够直接经过类自己进行构造!
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }

}

输出结果:

这是外部类方法!
null
这是静态内部类方法!
Inner Class

4.匿名内部类

匿名内部类:没有名字的内部类。

匿名内部类主要应用于接口的实现!

接口:

package NeiBuLei;

public interface MyInterface {
   
   
    public void test();
}

实现类:

package NeiBuLei;

public class MyImplement implements MyInterface{
   
   
    @Override
    public void test() {
   
   
        System.out.println("test");
    }
}

匿名内部类的使用:

package NeiBuLei;

public class Test {
   
   
    public static void main(String[] args) {
   
   
        
        //实现类
        MyInterface myInterface = new MyImplement();
        myInterface.test();
        
        //匿名内部类
        MyInterface myInterface1 = new MyInterface() {
   
    // 接口是不能new的,这里new的是接口的实现类(和实现类是同样的(同一个东西),没有实例而已)
            @Override
            public void test() {
   
   
                System.out.println("test");
            }
        };
        myInterface.test();
        /**
         * 最终两种实现方式的结果都是同样的!
         */
    }
}

匿名内部类的好处:

咱们定义接口以后,它的实现类不须要单首创建一个文件去写它的实现,咱们能够把这个实现类的操做写到咱们调用的地方就能够了!写起来更加简洁、方便。