Java SE

package com.liu.day01;

public class User {
    //创建静态成员变量
    public static int onlineNumber = 100;

    //实例成员变量，属于每个对象，必须要用对象名访问
    private String name;
    private  int age;

    public static void main(String[] args) {
        //1.通过 类名.静态成员变量 来访问静态成员变量
        System.out.println(User.onlineNumber);
        //2.通过 对象.静态成员变量 来访问静态成员变量
        User user = new User();
        System.out.println(++user.onlineNumber);
        //同一个类中的静态成员变量的访问可以省略类名
        user.onlineNumber++;
        System.out.println(onlineNumber);
        //实例成员变量访问
        user.name = "zhenxi";
        user.age = 23;
        System.out.println(user.age);
        System.out.println(user.name);
    }
}

package com.liu.day01;

public class Student {
    private String studentName;
    private String studentId;
    //静态成员方法：属于该类
    public static int getMax(int age1,int age2){
        return age1>age2 ? age1:age2;
    }
    //实例方法：属于对象
    public void study(){
        System.out.println(studentName+"在好好学习。");
    }

    public static void main(String[] args) {
        //通过类直接访问静态成员方法
        System.out.println(getMax(10, 20));
        //通过对象来访问实例方法
        Student student = new Student();
        student.studentName="zhenxi";
        student.study();
        Student student1 = new Student();
        student1.studentName="努力";
        student1.study();
    }
}

package com.liu.day01;

import java.util.Random;
//工具类
public class LoginUtils {
    //工具类无需创建对象，故把工具类的构造器进行私有化。
    private LoginUtils(){}

    //创建一个随机验证码
    public static String createVerifyCode(int n){
        String code = "";
        String data = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            int index = random.nextInt(data.length());
            code += data.charAt(index);
        }
        return code;
    }
}

package com.liu.day01;

public class ArraysUtils {
    //首先，私有化构造器，使外部不能创建对象
    private ArraysUtils(){}
    //返回整数数组中的内容方法
    public static String toString(int[] array){
        //首先对传进来的数组进行校验
        if (array == null){
            return null;
        }

        //对数组中的内容进行拼接
        String result = "[";
        for (int i = 0; i < array.length; i++) {
            result += (i == array.length-1?array[i]:array[i]+",");
        }
        result += "]";
        return result;
    }
    //统计平均值 只考虑浮点型数组
    public static float getAerage(float[] array){
        //首先对传进来的数组进行校验
        if (array == null){
            return 0;
        }
        float aerAge = 0;
        float max=array[0];//最大值
        int maxIndex=0;//最大值索引
        float min=array[0];//最小值
        int minIndex=0;//最小值索引
        //通过循环找出最大值最小值
        for (int i = 0; i < array.length; i++) {
            if (max<array[i]){
                max = array[i];
                maxIndex = i;
            }
            if (min>array[i]){
                min = array[i];
                minIndex = i;
            }
        }
        //定义一个新数组，将除去最大值最小值的数据放入新数组中
        float[] newArray= new float[array.length-2];
        int j = 0;

        for (int i= 0; i < array.length; i++) {
            if (!(i == maxIndex || i == minIndex)){
                newArray[j]=array[i];
                j++;
            }
        }
    //求得新数组中的总数
        float sum=0;
        for (int i = 0; i < newArray.length; i++) {
            sum += newArray[i];
        }
    //获得平均值
        aerAge=sum/array.length;
        return aerAge;
    }
}

package com.liu.day01;

import java.util.ArrayList;

public class StaticDemo2 {
    /*
    * 静态资源*/
    public static String schoolName;

    /*
    * 实例资源*/
    private String name;

    //静态代码块 可以用于初始化静态设置
    static {
        System.out.println("---静态代码块被执行---");
        schoolName = "zhenxi";
    }

    //实例代码块 不常用了解即可
    {
        System.out.println("---实例代码块执行---");
        name="努力";
    }
    //无参构造
    public StaticDemo2(){
        System.out.println("---无参构造执行---");
    }

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

---静态代码块被执行---
---main方法执行---
zhenxi
---实例代码块执行---
---无参构造执行---
努力

Process finished with exit code 0

package com.liu.day01;

import java.util.ArrayList;

public class StaticDemo3 {

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

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

    public static void main(String[] args) {
        System.out.println(cards);
    }
}

package com.liu.day01;

public class SingleInstance {
    //第一步：私有化构造器
    private SingleInstance(){}
    //第二步：创建一个静态对象
    public static SingleInstance singleInstance = new SingleInstance();
}

package com.liu.day01;

public class Test2 {
    public static void main(String[] args) {
        //通过类. 来获得对象
        SingleInstance singleInstance = SingleInstance.singleInstance;
    }
}

package com.liu.day01;

public class SingleInstance2 {
    //1.私有化构造器
    private SingleInstance2(){}
    //2.创建一个静态变量 这里私有化是为了防止通过类名.静态成员变量获得instance
    private static SingleInstance2 instance;
    //3.提供一个方法，对外返回单例对象
    public static SingleInstance2 getInstance(){
        //首先判断instance是否第一次创建，若是则创建对象，若不是则直接返回对象。
        if (instance == null){
            instance =new SingleInstance2();
        }
        return instance;
    }
}

package com.liu.day01;

public class Test2 {
    public static void main(String[] args) {
        //通过类.静态成员方法 来获得对象
        SingleInstance2 instance = SingleInstance2.getInstance();
    }
}

package com.liu.day01.extends_test;

public class People {
    //子类都有的属性
    private String name;
    private int age;
    //子类都有的方法
    public void lookCourse(){
        System.out.println("查看课表");
    }

    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 com.liu.day01.extends_test;

public class Teacher extends People{
    //子类特有的属性
    private String department;
    //子类特有的方法
    public void releaseIssues(){
        System.out.println("发布问题~");
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }
}

package com.liu.day01.extends_test;

public class Student extends People{
    //子类特有的属性
    private String className;
    //子类特有的方法
    public void learning(){
        System.out.println("听课");
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

package com.liu.day01.extends_test;

public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.lookCourse();
        student.learning();
        student.setName("zhenxi");
        System.out.println(student.getName());
        student.setClassName("电子信息");
        System.out.println(student.getClassName());

        Teacher teacher = new Teacher();
        teacher.lookCourse();
        teacher.releaseIssues();
        teacher.setName("努力");
        System.out.println(teacher.getName());
        teacher.setDepartment("计控学院");
        System.out.println(teacher.getDepartment());
    }
}

package com.liu.day01.extends_test;

import java.util.Calendar;

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.showId();
    }
}
class Animal{
    //父类范围
    public int id = 10;
    public void eat(){
        System.out.println("吃东西~");
    }
}
class Cat extends Animal{
    //子类范围
    public int id = 11;
    public void eat(){
        System.out.println("吃猫粮");
    }
    public void showId(){
        //局部
        int id = 12;
        System.out.println(id);
    }
}

package com.liu.day01;

public class Override_Test {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.setMessage();
    }
}
class OldPhone{
    public void call(){
        System.out.println("打电话");
    }
    public void setMessage(){
        System.out.println("发送消息");
    }
}
class NewPhone extends OldPhone{
    @Override
    public void call(){
        System.out.println("打电话");
        System.out.println("视频通话");
    }
    @Override
    public void setMessage(){
        System.out.println("发送消息");
        System.out.println("发送图片");
    }
}

package com.liu.day01.constructor;

public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
        Student student1 = new Student(1);
    }
}
class People{
    private String name;
    public People(){
        System.out.println("父类无参构造执行");
    }
}

class Student extends People{
    private int id;
    public Student() {
        System.out.println("子类无参构造执行");
    }

    public Student(int id){
        this.id = id;
        System.out.println("子类有参构造执行");
    }
}

运行结果：
父类无参构造执行
子类无参构造执行
父类无参构造执行
子类有参构造执行

package com.liu.day01.constructor;

public class Test2 {
    public static void main(String[] args) {
        Zi zi = new Zi("zhenxi", 23);
    }
}
class Fu{
    private String name;
    private int id;

    public Fu() {
    }
    //父类的有参构造
    public Fu(String name, int id) {
        this.name = name;
        this.id = id;
    }
}

class Zi extends Fu{
    public Zi() {
    }
    //使用super()初始化父类有参构造中的参数
    public Zi(String name, int id) {
        super(name, id);
    }
}

package com.liu.day02.authority_Test;

public class Fu {
    private void privatePrint(){
        System.out.println("私有权限");
    }
    void print(){
        System.out.println("缺省权限");
    }
    protected void protectedPrint(){
        System.out.println("受保护权限");
    }
    public void publicPrint(){
        System.out.println("公共权限");
    }
    //同一个类中可以全部访问
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.privatePrint();
        fu.print();
        fu.protectedPrint();
        fu.publicPrint();
    }
}

package com.liu.day02.authority_Test;

public class Student {
    public static void main(String[] args) {
        //同一个包中的其它类：不能访问私有
        Fu fu = new Fu();
        fu.protectedPrint();
        fu.print();
        fu.publicPrint();
    }
}

package com.liu.day02.authority_Test2;

import com.liu.day02.authority_Test.Fu;

public class Zi extends Fu{
    public static void main(String[] args) {
        //不同包下的子类能够访问受保护的以及公有的
        Zi zi = new Zi();
        zi.protectedPrint();
        zi.publicPrint();
    }
}

package com.liu.day02.authority_Test2;

import com.liu.day02.authority_Test.Fu;

public class Teacher {
    public static void main(String[] args) {
        //不同包，且无关系类，只能使用公有权限。
        Fu fu = new Fu();
        fu.publicPrint();
    }
}

public final class Season extends java.lang.Enum<Season> {
  public static final Season SPRING;
  public static final Season SUMMER;
  public static final Season AUTUMN;
  public static final Season WINTER;
  public static Season[] values();
  public static Season valueOf(java.lang.String);
  static {};
}

package com.liu.day02.abstract_Test;

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

    public abstract void pay(double payMoney);

    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 com.liu.day02.abstract_Test;

public class GoldenCard extends Card{

    @Override
    public void pay(double payMoney) {
        payMoney = 0.8 * payMoney;
        System.out.println("应支付"+payMoney);
        super.setMoney(super.getMoney() - payMoney);
        System.out.println("余额"+ super.getMoney());
    }
}

package com.liu.day02.abstract_Test;

public class SilverCard extends Card{
    @Override
    public void pay(double payMoney) {
        payMoney = 0.85 * payMoney;
        System.out.println("应支付"+payMoney);
        super.setMoney(super.getMoney() - payMoney);
        System.out.println("余额"+ super.getMoney());
    }
}

package com.liu.day02.abstract_Test;

public class Test1 {
    public static void main(String[] args) {
        GoldenCard goldenCard = new GoldenCard();
        goldenCard.setMoney(1000.0);
        goldenCard.pay(200);
        SilverCard silverCard = new SilverCard();
        silverCard.setMoney(1000.0);
        silverCard.pay(200);
    }
}

应支付160.0
余额840.0
应支付170.0
余额830.0

package com.liu.day02.abstract_Test1;

public abstract class Student {

    //将该方法加上final关键字，使其变成最终方法
    public final void write(){
        System.out.println("题目：《我的爸爸》");
        System.out.println("我的爸爸是一个普通的平凡人。");
        System.out.println(text());
        System.out.println("我爱我的爸爸。");
    }
    //编写抽象方法
    public abstract String text();
}

package com.liu.day02.abstract_Test1;

public class StudentPupil extends Student{
    @Override
    public String text() {
        return "谢谢你，父亲。";
    }
}

package com.liu.day02.abstract_Test1;

public class StudentMiddle extends Student{
    @Override
    public String text() {
        return "愿您一生健康。";
    }
}

package com.liu.day02.abstract_Test1;

public class Test1 {
    public static void main(String[] args) {
        StudentMiddle studentMiddle = new StudentMiddle();
        studentMiddle.write();
        StudentPupil studentPupil = new StudentPupil();
        studentPupil.write();
    }
}

package com.liu.day03.polymorphic;

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

package com.liu.day03.polymorphic;

public class Computer {
    public void installUsb(USB usb){
        usb.connect();
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.click();
        }else if (usb instanceof Keyboard){
            Keyboard keyboard = (Keyboard) usb;
            keyboard.typing();
        }
        usb.unConnect();
    }
}

package com.liu.day03.polymorphic;

public class Mouse implements USB{
    @Override
    public void connect() {
        System.out.println("鼠标连接成功");
    }
    public void click(){
        System.out.println("鼠标点击功能");
    }

    @Override
    public void unConnect() {
        System.out.println("鼠标断开连接");
    }
}

package com.liu.day03.polymorphic;

public class Keyboard implements USB{
    @Override
    public void connect() {
        System.out.println("键盘连接成功");
    }
    public void typing(){
        System.out.println("键盘打字功能");
    }

    @Override
    public void unConnect() {
        System.out.println("键盘断开连接");
    }
}

package com.liu.day03.polymorphic;

public class Test2 {
    public static void main(String[] args) {
        USB usb1 = new Mouse();
        USB usb2 = new Keyboard();
        Computer computer = new Computer();
        computer.installUsb(usb1);
        computer.installUsb(usb2);
    }
}

运行结果：
鼠标连接成功
鼠标点击功能
鼠标断开连接
键盘连接成功
键盘打字功能
键盘断开连接

Process finished with exit code 0

package com.liu.day03.innerClass;

public class StaticInnerClass {

    private String className;
    public static int classId;
    public final int CLASS_ID = 2;

    //静态内部类
    public static class InClass{
        //实例成员
        private String name;

        public InClass() {
        }

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        //静态成员
        public static int id;

        //常量
        public final int USER_ID = 12;


        //静态内部类能调用主类
        public void getInnerClass(){
            //只能调用静态成员~
            classId = 10;
        }

    }

    public static void main(String[] args) {
        //创建静态内部类对象的格式
        InClass aClass = new StaticInnerClass.InClass();
    }
}

package com.liu.day03.innerClass;

public class OnClass {
    private String name;
    private static int id;

    public static void setId(){
        id = 12;
    }
    //实例内部类
    public class InnerClass{
        private String inName;
        //这里使用的是8版本 所以不能在实例内部类中创建静态成员
        //public static int inId;
        public void getOnClass(){
            //可以调用实例成员
            name = "zhenxi";
            //可以调用静态成员
            id = 13;
            setId();
        }
    }

    public static void main(String[] args) {
        //实例内部类创建对象的格式
        InnerClass innerClass = new OnClass().new InnerClass();
        innerClass.getOnClass();
    }
}

package com.liu.day03.innerClass;

public class People {
    private int heartbeat = 90;
    public class Heart{
        private int heartbeat = 100;

        public void show(){
            int heartbeat = 120;
            System.out.println(heartbeat); //调用局部变量
            System.out.println(this.heartbeat);//调用内部类的实例对象
            System.out.println(People.this.heartbeat);//调用外部类的实例对象
        }
    }

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

/*运行结果
  120
  100
  90
*/

package com.liu.day03.innerClass;

public class Test {
    static {
        //静态代码块中的局部内部类
        class Dog{
            private String dogName;

            public Dog() {
            }

            public Dog(String dogName) {
                this.dogName = dogName;
            }
        }
    }
    public static void main(String[] args) {
        //局部内部类 创建于main方法中
        class Cat{
            private String name;
            private int id;

            public Cat() {
            }

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

            public String getName() {
                return name;
            }

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

            public int getId() {
                return id;
            }

            public void setId(int id) {
                this.id = id;
            }
        }
        Cat cat = new Cat("橘猫",2);
    }
}

package com.liu.day03.innerClass;


public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳");
            }
        };
        go(s);

        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师贼快~~~~~");
            }
        };
        go(s1);

        System.out.println("--------------");

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员🏊的贼快啊~~~~~");
            }
        });
    }

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


interface Swimming{
    void swim();
}

package com.liu.day03.innerClass;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


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

    }
}

package com.liu.day03.object_Test;

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

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

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

package com.liu.day03.object_Test;

public class Test {
    public static void main(String[] args) {
        Student student = new Student("zhenxi",2022935775);
        Student student1 = new Student("成龙",2022935776);
        System.out.println(student.toString());
        System.out.println(student.equals(student1));
    }
}
/**
运行结果：
com.liu.day03.object_Test.Student@1540e19d
false
*/

    @Override
    public boolean equals(Object o) {
        //首先判断传进来的对象是不是原对象
        if (this == o) return true;
        //判断传进来的对象是否为空，以及判断是否与本对象是不是同一个类型
        if (o == null || getClass() != o.getClass()) return false;
        //将传进来的对象转成Student类型对象
        Student student = (Student) o;
        //判断对象中的内容是否相同
        return id == student.id && Objects.equals(name, student.name);
    }

  //将对象的内容输出出去
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

package com.liu.day03.object_Test;

public class Test {
    public static void main(String[] args) {
        Student student = new Student("zhenxi",2022935777);
        Student student1 = new Student("成龙",2022935776);
        System.out.println(student.toString());
        System.out.println(student1.toString());
        System.out.println(student.equals(student));
        System.out.println(student.equals(student1));
    }
}

/**
运行结果：
Student{name='zhenxi', id=2022935775}
Student{name='成龙', id=2022935776}
true
false
*/

 public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
  }

public class Test3 {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "liu";
        s1.equals(s2);
    }
}
/**
运行结果
Exception in thread "main" java.lang.NullPointerException
  at com.liu.day03.object_Test.Test3.main(Test3.java:7)
*/