javaSe基础进阶知识笔记1

Static关键字

修饰成员变量、内存机制

package org.example.d1_static;

public class User {
    public static int onlineNumber=161;
    /**
     * 实例成员变量：无static修饰，属于每个对象，只能用对象名.成员变量名访问
     */
    private String name;
    private int age;
    public static void main(String[] args) {
        //目标：理解static修饰成员变量的作用和访问特点
        //1.类名.成员变量名
        System.out.println(User.onlineNumber);
//        System.out.println(User.age);//不能使用类名.
//        2.对象名.成员变量名
        User u=new User();

        u.age=11;
        System.out.println(u.age);
        u.name="张三";
        System.out.println(u.name);
        u.onlineNumber++;
        System.out.println(u.onlineNumber);
    }
}

static修饰成员方法的基本用法和内存机制

package org.example.d1_static;

public class Student {
    private String name;

    /**
     * 静态成员方法
     *
     * @param age1
     * @param age2
     * @return
     */
    public static int getMax(int age1, int age2) {
        return age1 > age2 ? age1 : age2;
    }
    /**
     * 实例成员方法
     */
    public void study(){
        System.out.println(name+"好好学习，天天向上");
    }

    public static void main(String[] args) {
        //类名.成员方法名
        System.out.println(Student.getMax(12, 35));
        //注意：同一个类中类名可以省略不写
        System.out.println(getMax(13, 34));

        //对象.实例方法
        Student s=new Student();
        s.name="猪八戒";
        s.study();

        //不推荐
        System.out.println(s.getMax(15, 24));
    }

}

static注意事项

package org.example.d1_static;

public class Test3 {
    //目标：理解static 访问相关语法 面试笔试题



    /**
     * 静态成员
     */
    public static int onlineNumber=89;
    public static void test2(){

        System.out.println("===test2=====");
    }

    /**
     * 实例成员
     */
    private String name;
    public void run(){
        System.out.println(name+"跑得块");
    }
    //3.静态方法中不可以出现this关键字
    public static void test3(){
//        System.out.println(this);//this代表当前对象
    }

    //2.实例方法可以访问静态成员，也可以访问实例成员
    public void go(){
        System.out.println(Test3.onlineNumber);
        test2();
        System.out.println(name);
        run();
    }

    //1.静态方法只能访问静态成员，不能直接访问实例成员
    public static void test(){
        System.out.println(Test3.onlineNumber);
        test2();
//        System.out.println(name);//不能直接访问实例成员
//        run();
    }

}

static应用知识-工具类

工具类是什么？
类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的

package org.example.d2_static_util;

import java.util.Random;

/**
 * 工具类
 */
public class Util {

    /**
     * 注意：由于工具类无需创建对象，所以将其构造器私有化
     */
    private Util(){
    }
    /**
     * 静态方法
     * @return
     */
    public static String createVerifyCode(int n){
        //开发一个验证码
        String code = "";
        String data = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(data.length());
            code += data.charAt(index);
        }
        return code;
    }
}

package org.example.d2_static_util;

public class ArrayUtil {
    /*
    构造器私有
     */
    private ArrayUtil(){

    }

    /*
    静态方法
     */
    public static String toString(int[] arr){
        if (arr==null){
            return null;
        }
        String result="[";
        for (int i = 0; i < arr.length; i++) {
            result +=(i==arr.length-1?arr[i]:arr[i]+", ");
        }
        result+="]";
        return result;
    }
}

static应用知识-代码块

package org.example.d3_static_code;

public class StaticDemo1 {

    public static String schoolName;
    /**
     * 静态代码块，有static修饰，属于类，与类一起优先加载一次，自动触发执行
     * 作用：可以用于初始化一些静态资源
     */
    static {
        System.out.println("-------------静态代码块被执行-----------");
        schoolName="黑马";

    }

    public static void main(String[] args) {
        System.out.println("==========main方法执行================");
        System.out.println(schoolName);
    }
}

package org.example.d3_static_code;

public class StaticDemo2 {
    private String name;
    public StaticDemo2(){
        System.out.println("======无参构造器被触发执行======");
    }

    /**
     * 理解实例代码块（构造代码块）：无static修饰，属于对象，每次构建对象时都会触发一次
     * 初始化实例资源
     */
    {
        System.out.println("===========实例代码块被触发执行==========");
        name="张三";
    }

    public static void main(String[] args) {
        StaticDemo2 s1=new StaticDemo2();
        System.out.println(s1.name);
        StaticDemo2 s2=new StaticDemo2();

    }
}

静态代码块的应用案例

package org.example.d3_static_code;

import java.util.ArrayList;

public class StaticTest3 {
    public static ArrayList<String> cards=new ArrayList<>();

    static {
        String[] size={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] colors={"♥","♣","♦","♠"};
        for (int i = 0; i < size.length; i++) {
            for (int j = 0; j < colors.length; j++) {
                String card=size[i]+colors[j];
                cards.add(card);
            }
        }
        cards.add("小王");
        cards.add("大王");
    }

    public static void main(String[] args) {
        System.out.println("新牌："+cards);
    }
}

static应用知识-单例模式

package org.example.d4_static_singleinstance;

public class SingleInstance {

    private static SingleInstance instance;

    public static SingleInstance getInstance(){
        if (instance==null){
            instance=new SingleInstance();
        }
        return instance;
    }
    /**
     * 构造器私有
     */
    private SingleInstance(){}
}

package org.example.d4_static_singleinstance;

public class Test1 {
    public static void main(String[] args) {
        SingleInstance instance=SingleInstance.getInstance();
        System.out.println(instance);
    }
}

继承

概述、案例

package org.example.d5_extends;

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

    public void queryCourse(){
        System.out.println(name+"在查看课表");
    }

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

package org.example.d5_extends;

public class Student extends People{
    public void writeInfo(){
        System.out.println(getName()+"意见反馈");
    }
}

package org.example.d5_extends;

public class Test {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("孙悟空");
        s.setAge(18000);
        System.out.println(s.getAge());
        System.out.println(s.getName());
        s.queryCourse();
        s.writeInfo();
    }
}

特点、访问特点、方法重写

子类的对象用this关键字

构造器特点，this、super小结

package org.example.d6_extends_filed_method;

public class Student {
    private String name;
    private String schoolName;

    public Student() {

    }

    /**
     * 不填写学校，只填写姓名
     */
    public Student(String name){
        //借用兄弟构造器
        this(name,"黑马程序员");
    }

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

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

package org.example.d6_extends_filed_method;

public class Test {
    public static void main(String[] args) {
        //目标：理解this()的作用：本类构造器中访问本类兄弟构造器
        Student s1=new Student("孙悟空","天地学院自学");
        Student s2=new Student("张三丰");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}

语法

包

权限修饰符

protected访问控制符在其他包的子类中只能用子类对象访问，不能用父类对象

final

package org.example.d3_final;

public class Test {
    //修饰静态成员变量
    public static final String schoolName = "黑马";

    public static void main(String[] args) {
        //目标：记住final的语法
        //1.final修饰类，类不能被继承
        //2.final修饰方法，方法不能被重写
        //3.final修饰变量，变量有且只能被赋值一次
        final double rate = 3.14;
//        rate=90;
//        schoolName="上";

        //final修饰引用类型的变量
        final Teacher t=new Teacher("猪八戒");
//        t=null;
        t.setName("猴子");

    }
}

class Teacher {
    private String name="孙悟空";

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

    public String getName() {
        return name;
    }

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

/*
2.修饰方法
class Student extends People{
    @Override
    public void eat() {
        System.out.println("学生要吃很多饭");
    }
}

class People{
    public final void eat(){
        System.out.println("人要吃饭");
    }
}
*/

/*
1.final修饰类
class Wolf extends Animal{

}

final class Animal{

}
*/

常量

枚举

package org.example.d5_enum;

/**
 * 枚举类
 */
public enum Season {
    //枚举类的第一行必须罗列枚举类的对象名称，建议全部大写
    SPRING,SUMMER,AUTUMN,WINTER;
}

抽象类

package org.example.d7_abstract_test;

public abstract class Card {
    private String userName;
    private double money;


    /**
     * 定义一个支付方法：表示卡片可以支付
     * 抽象方法
     * @param money
     */
    public abstract void pay(double money);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

package org.example.d7_abstract_test;

public class GoldCard extends Card{
    @Override
    public void pay(double money) {
        System.out.println("您当前消费："+money);
        System.out.println("您实际余额是："+getMoney());
        //优惠价
        double rs=money*0.8;
        System.out.println("您实际消费为："+rs);
        //更新账户余额
        setMoney(getMoney()-rs);
    }
}

package org.example.d7_abstract_test;

public class Test {
    public static void main(String[] args) {
        //目标：学习一下抽象类的基本使用，做父类，被继承，重写抽象方法
        GoldCard c=new GoldCard();
        c.setMoney(10000);
        c.setUserName("孙悟空");

        c.pay(800);
        System.out.println("您的剩余余额为："+c.getMoney());
    }
}

package org.example.d8_abstract_template;

public abstract class Student {
    public final void write() {
        System.out.println("\t\t\t\t《我的爸爸》");
        System.out.println("你的爸爸是啥样，来说说：");
        System.out.println(writeMain());
        System.out.println("你的爸爸确实太好了");
    }

    public abstract String writeMain();
}

package org.example.d8_abstract_template;

public class StudentChild extends Student{
    @Override
    public String writeMain() {
        return "我的爸爸总是给我买东西吃~~~";
    }
}

package org.example.d8_abstract_template;

public class StudentMiddle extends Student{
    @Override
    public String writeMain() {
        return "我的爸爸总是给我很多钱~~~~~~~~";
    }
}

package org.example.d8_abstract_template;

public class Test {
    public static void main(String[] args) {
        //目标：理解模板方法模式的思想和使用步骤
        StudentMiddle s1=new StudentMiddle();
        s1.write();
        StudentChild s2=new StudentChild();
        s2.write();
    }
}

接口

package org.example.d9_interface;

/**
 * 申明一种方法，体现一种规范，规范一定是公开的
 */
public interface InterfaceDemo {
    //目标：接口中的成分特点，jdk8之前为常量和抽象方法
    //1.常量
    //注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面public static final可以默认不写
    String name="黑马程序员";
//    public static final String name="黑马程序员";

    
    //2.抽象方法
    //注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面public abstract可以默认不写
    void run();
//    public abstract void run();
}

package org.example.d10_interface_implement;

public interface SportMan {
    void run();
    void competition();
}

package org.example.d10_interface_implement;

public class PingPongMan implements SportMan{
    private String name;

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

    @Override
    public void run() {
        System.out.println(name+"必须要跑步训练~~");
    }

    @Override
    public void competition() {
        System.out.println(name+"要参加比赛，为国争光！");
    }
}

package org.example.d10_interface_implement;

public class Test {
    public static void main(String[] args) {
        //目标：理解接口的基本使用，被类实现
        PingPongMan p=new PingPongMan("许欣");
        p.run();
        p.competition();
    }
}

package org.example.d10_interface_implement;

public interface SportMan extends Low,People{
    void run();
    void competition();
}

package org.example.d10_interface_implement;

public interface Low {
    void rule();
}

package org.example.d10_interface_implement;

public interface People {
    void eat();
}

package org.example.d10_interface_implement;

public class PingPongMan implements SportMan{
    private String name;

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

    @Override
    public void run() {
        System.out.println(name+"必须要跑步训练~~");
    }

    @Override
    public void competition() {
        System.out.println(name+"要参加比赛，为国争光！");
    }

    @Override
    public void rule() {
        
    }

    @Override
    public void eat() {

    }
}

package org.example.d11_interface_extends;

public interface SportMan {
    /**
     * 1.jdk8开始：默认方法（实例方法）
     * 必须用default修饰，默认用public修饰
     * 只能过继给实现类，由实现类的对象进行调用
     */
    default void run(){
        //go();
        System.out.println("跑的快~~");
    }
    /**
     * 2.静态方法
     * 必须用static修饰，默认用public修饰
     * 接口的静态方法，必须用接口名来调用
     */
    static void inAddr(){
        System.out.println("静态方法的调用");
    }

    /**
     * 3.私有方法
     * jdk9才开始使用 必须在接口内部才能使用
     */
//    private void go(){
//        System.out.println("开始跑~~");
//    }
}

class PingPongMan implements SportMan{

}

class Test{
    public static void main(String[] args) {
        PingPongMan p=new PingPongMan();
        p.run();

        SportMan.inAddr();
    }
}

多态

package org.example.d1_polymophic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */
public class Test {
    public static void main(String[] args) {
        //多态形式          父类类型   对象名称=new 子类构造器
        Animal a=new Dog();
        a.run();//对于方法：编译看左边，运行看右边
        System.out.println(a.name);//对于变量：编译看左，运行也看左

        Animal a2=new Tortoise();
        a2.run();//编译看左边，运行看右边
        System.out.println(a2.name);
    }
}

class Tortoise extends Animal{
    public String name="子类乌龟";

    @Override
    public void run() {
        System.out.println("乌龟跑的很慢");
    }
}

class Dog extends Animal{

    public String name="子类狗";

    @Override
    public void run() {
        System.out.println("狗跑得很快");
    }
}

abstract class Animal{
    public String name="父类动物";
    public abstract void run();
}

package org.example.d1_polymophic;

/**
 * 目标：学习多态类型下的自动类型转换
 */
public class Test {
    public static void main(String[] args) {
        //自动类型转换
        Animal a=new Dog();
        a.run();

        //强制类型转换
        Animal a2=new Tortoise();
        a2.run();

        Tortoise t= (Tortoise) a2;//从父类类型到子类类型必须强制类型转换
        t.layEggs();

//        Dog d= (Dog) a2;//强制类型转换，编译时不会报错

        if (a2 instanceof Tortoise){
            Tortoise t1= (Tortoise) a2;
        }else if (a2 instanceof Dog){
            Dog d2= (Dog) a2;
            d2.lookDoor();
        }

    }
}

class Tortoise extends Animal{
    public String name="子类乌龟";

    @Override
    public void run() {
        System.out.println("乌龟跑的很慢");
    }

    /**
     * 独有方法
     */
    public void layEggs(){
        System.out.println("乌龟在下蛋");
    }

}

class Dog extends Animal{

    public String name="子类狗";

    @Override
    public void run() {
        System.out.println("狗跑得很快");
    }
    /**
     * 独有功能
     */
    public void lookDoor(){
        System.out.println("狗在看门");
    }
}

abstract class Animal{
    public String name="父类动物";
    public abstract void run();
}

package org.example.d2_polymophic_test;

public class Computer {
    private String name;

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

    public void start(){
        System.out.println(name+"电脑开机了");
    }

    /**
     * 提供安装USB的设备入口
     */
    public void installUSB(USB u){
        //多态
        u.connect();
        //独有功能:先判断，再强转
        if (u instanceof KeyBoard){
            KeyBoard k= (KeyBoard) u;
            k.keyDown();
        }else if (u instanceof Mouse){
            Mouse m= (Mouse) u;
            m.dbClick();
        }
        u.unconect();
    }

    public String getName() {
        return name;
    }

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

package org.example.d2_polymophic_test;

public class KeyBoard implements USB{
    private String name;

    public String getName() {
        return name;
    }

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

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


    /**
     * 独有功能
     */

    public void keyDown(){
        System.out.println(name+"敲击了：来了老弟，666");
    }


    @Override
    public void connect() {
        System.out.println(name+"成功连接电脑");
    }

    @Override
    public void unconect() {
        System.out.println(name+"成功从电脑中断开");
    }
}

package org.example.d2_polymophic_test;

public class Mouse implements USB{
    private String name;

    public String getName() {
        return name;
    }

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

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


    /**
     * 独有功能
     */

    public void dbClick(){
        System.out.println(name+"双击点亮小红心");
    }


    @Override
    public void connect() {
        System.out.println(name+"成功连接电脑");
    }

    @Override
    public void unconect() {
        System.out.println(name+"成功从电脑中断开");
    }
}

package org.example.d2_polymophic_test;

public class Test {
    public static void main(String[] args) {
        //创建电脑对象
        Computer c=new Computer("联想");
        c.start();

        //创建鼠标和键盘对象
        USB u=new Mouse("华为");
        c.installUSB(u);

        USB u1=new KeyBoard("小米键盘");
        c.installUSB(u1);
    }
}

package org.example.d2_polymophic_test;

public interface USB {
    void connect();
    void unconect();
}

内部类

概述

静态内部类

package org.example.d5_innerclass_static;

/**
 * 外部类
 */
public class Outer {

    public static int a=10;
    private String hobby;

    /**
     * 学习静态成员内部类
     */
    public static class Inner{
        private String name;
        private int age;
        public static String SchoolName="黑马";

        public Inner() {
        }

        public void show(){
            System.out.println(a);
//            System.out.println(hobby);//报错！
//            Outer o=new Outer();
//            System.out.println(o.hobby);
        }

        public Inner(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;
        }
    }
}

package org.example.d5_innerclass_static;

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer.Inner("张三",23);
        System.out.println(inner.getAge());
        System.out.println(inner.getName());
    }
}

成员内部类

package org.example.d5_innerclass_static;

/**
 * 外部类
 */
public class Outer {

    public static int a=10;
    private String hobby="打球，游泳，下棋";

    /**
     * 学习成员内部类，不加static修饰，属于外部类
     */
    public class Inner{
        private String name;
        private int age;
        //public static String SchoolName="黑马";//jdk16开始支持

        public Inner() {
        }

        public void show(){
            System.out.println("静态"+a);
            System.out.println(hobby);
//            Outer o=new Outer();
//            System.out.println(o.hobby);
        }

        public Inner(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;
        }
    }
}

package org.example.d5_innerclass_static;

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer().new Inner("张三",23);
        System.out.println(inner.getAge());
        System.out.println(inner.getName());
        inner.show();
    }
}

package org.example.d6_innerclass;

public class Test {
    public static void main(String[] args) {
        People.Heart heart=new People().new Heart();
        heart.show();
    }
}

class People{
    private int heartbeat=150;
    public class Heart{
        private int heartbeat=110;

        public void show(){
            int heartbeat=78;
            System.out.println(heartbeat);//78
            System.out.println(this.heartbeat);//110
            System.out.println(People.this.heartbeat);//150
        }
    }
}

局部内部类

package org.example.d7_innerclass;

/**
 * 了解局部内部类
 */
public class Test {
    public static void main(String[] args) {
        class Cat{
            private String name;

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
        Cat c=new Cat();
        c.setName("叮当猫~");
        System.out.println(c.getName());
    }
}

匿名内部类

package org.example.d8_innerclass_anonymous;

/**
 * 目标：学习匿名内部类的格式和特点
 */

public class Test {
    public static void main(String[] args) {
        Animal a=new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑的快");
            }
        };
        a.run();
    }
}

abstract class Animal{
    public abstract void run();

}

package org.example.d8_innerclass_anonymous;

/**
 * 目标：学习匿名内部类的使用方式
 */
public class Test2 {
    public static void main(String[] args) {
        Swimming s=new Swimming() {
            @Override
            public void run() {
                System.out.println("学生游泳游得很快乐");
            }
        };
        go(s);
        System.out.println("=======================");
        Swimming s2=new Swimming() {
            @Override
            public void run() {
                System.out.println("老师游得很笨拙");
            }
        };
        go(s2);

        System.out.println("===========================");
        go(new Swimming() {
            @Override
            public void run() {
                System.out.println("运动员游的很快");
            }
        });

    }

    public static void go(Swimming s){
        System.out.println("开始");
        s.run();
        System.out.println("结束");
    }
}

interface Swimming{
    void run();
}

package org.example.d8_innerclass_anonymous;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * 通过GUI编程 理解匿名内部类的真实使用场景
 */

public class Test3 {
    public static void main(String[] args) {
        //1.创建窗口
        JFrame win=new JFrame("登录界面");
        JPanel panel=new JPanel();
        win.add(panel);

        //2.创建按钮

        JButton btn=new JButton("登录");

       /* //注意：讲解匿名内部类的使用
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(win,"点我一下说明爱我");
            }
        });*/

        btn.addActionListener(e -> JOptionPane.showMessageDialog(win,"别说话，吻我！") );

        //3.将按钮添加到桌布
        panel.add(btn);

        //4.展示窗口
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
    }
}

常用API

Object

都是为了让子类区重写

package org.example.d9_api_object;

import java.util.Objects;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

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

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

}

package org.example.d9_api_object;

/**
 * 目标：掌握object类中toString方法和equals方法的使用
 */

public class Test1 {
    public static void main(String[] args) {
        Student s=new Student("孙悟空",'男',4567);
        System.out.println(s.toString());
        //直接输出对象变量，默认可以省略toString调用不写的
        System.out.println(s);

        Student s1=new Student("孙悟空",'男',4567);
        Student s2=new Student("孙悟空",'男',4567);
        //equals默认比较俩个对象的地址是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1==s2);
    }
}

Objects

package org.example.d10_api_objects;

import java.util.Objects;

/**
 * 目标：掌握objects的常用方法：equals和isNull方法
 */
public class Test {
    public static void main(String[] args) {
        String s1=null;
        String s2=new String("heima ");

        System.out.println(Objects.equals(s1,s2));

        System.out.println(Objects.isNull(s1));
    }
}

StringBuild

package org.example.d11_api_stringbuilder;

/**
 *
 *  目标：学会使用stringBuilder操作字符串
 */
public class StringBuilderDemo1 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(false);
        sb.append(6);
        sb.append(9.0);
        System.out.println(sb);

        //支持链式编程
        StringBuilder sb1=new StringBuilder();
        sb1.append("a").append("b").append("c").append("我爱你中国");
        System.out.println(sb1);

        //反转
        sb1.reverse().append(110);
        System.out.println(sb1);

        System.out.println(sb1.length());

        //注意：StringBuild只是拼接字符串的手段，效率好
        //最终目的还是要恢复成String类型
        StringBuilder sb2=new StringBuilder();
        sb2.append("d123").append("345");
        //恢复成String类型
        String rs=sb2.toString();
        check(rs);
    }
    public static void check(String data){
        System.out.println(data);
    }
}

String主要每次都创建俩个对象，比较费内存，所以StringBuild性能更好，因为只创建一次且一个StringBuild对象。

package org.example.d11_api_stringbuilder;

public class StringBuildTest2 {
    public static void main(String[] args) {
        int[] arr1=null;
        System.out.println(toString(arr1));

        int[] arr2={56,8,35,56};
        System.out.println(toString(arr2));

        int[] arr3={};
        System.out.println(toString(arr3));
    }

    public static String toString(int[] arr){
        if (arr!=null){
            StringBuilder sb=new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i==arr.length-1?"":" ,");
            }
            sb.append("]");
            return sb.toString();
        }else {
            return null;
        }
    }
}

Math

package org.example.d12_math;

public class Demo1 {
    public static void main(String[] args) {
        //1.取绝对值
        System.out.println(Math.abs(10));//10
        System.out.println(Math.abs(-78));//78

        //2.向上取整
        System.out.println(Math.ceil(4.6789));//5.0
        //3.向下取整
        System.out.println(Math.floor(5.4567));//5.0
        //4.求指数次方
        System.out.println(Math.pow(2, 3));//8.0
        //5.四舍五入
        System.out.println(Math.round(456.678));//457
        System.out.println(Math.round(5.08));//5

        System.out.println(Math.random());//0.0~1.0

        //拓展 生成3-9之间的某个数
        int data=(int)((Math.random()*7)+3);
        System.out.println(data);
    }
}

System

package org.example.d13_system;

import java.lang.reflect.Array;
import java.util.Arrays;

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("程序开始");

        //System.exit(0);//jvm终止

        //计算机从1970年1.1日0:0:0开始走到现在的值
        long time=System.currentTimeMillis();
        System.out.println(time);
        //进行时间计算：性能分析
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println("输出"+i);
        }
        long endTime=System.currentTimeMillis();
        System.out.println((endTime-startTime)/1000.0+"s");

        //数组的拷贝
        /*
        arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
            被拷贝的数组
            从那个索引位置开始拷贝
            复制的目标数组
            粘贴位置
            拷贝元素个数
         */
        int[] arr1={10,20,30,40,50,60,70};
        int[] arr2=new int[6];//[0,0,0,0,0,0]===>[0,0,40,50,60,0]
        System.arraycopy(arr1,3,arr2,2,3);
        System.out.println(Arrays.toString(arr2));

        System.out.println("程序结束");
    }
}

BigDecimal

package org.example.d14_bigdecimal;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalDemo {
    public static void main(String[] args) {
        //浮点型运算存在精度失真问题
        System.out.println(0.09+0.01);
        System.out.println(1.0-0.32);
        System.out.println(1.015*100);
        System.out.println(1.301/100);
        //结果如下：
//        0.09999999999999999
//        0.6799999999999999
//        101.49999999999999
//        0.013009999999999999

        System.out.println("===========================");
        double a=0.1;
        double b=0.2;
        double c=a+b;
        System.out.println(c);
        System.out.println("=======================");

        //包装浮点型数据为大数据对象 BigDecimal
        BigDecimal a1=BigDecimal.valueOf(a);
        BigDecimal b1=BigDecimal.valueOf(b);
        BigDecimal c1=a1.add(b1);
        BigDecimal c2=a1.subtract(b1);
        BigDecimal c3=a1.multiply(b1);
        BigDecimal c4=a1.divide(b1);

        //目的：double
        double rs1=c1.doubleValue();
        System.out.println(rs1);

        System.out.println("====================");
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println("=================");
        //注意事项：bigDecimal一定要做精度运算
        BigDecimal a11=BigDecimal.valueOf(10.0);
        BigDecimal b11=BigDecimal.valueOf(3.0);
        /**
            参数一：除数 参数二：保留小数位 参数三：舍入模式
         */
        BigDecimal c11=a11.divide(b11,2, RoundingMode.HALF_EVEN);
        System.out.println(c11);
    }
}