B站韩顺平java学习笔记（七）--面向对象编程（中级）章节

public class DynamicBinding{
    public static void main(String[] args){
    A a = new B();//a的编译类型是 A，运行类型是B
    System.out.println(a.sum());
    System.out.println(a.sum1());
    }

}
class A{  //父类
    public int i = 10;

    public int sum(){
        return getI() + 10;
    }
    
    public int sum1(){
        return i + 10;
    }
    
    public int getI(){
        return i;
    }
}
class B extends A{  //子类
    public int i = 20;
    
    public int sum(){
        return i + 10;
    }
    
    public int sum1(){
        return i + 10;
    }
    
    public int getI(){
        return i;
    }
}

此时结果为40，30。

public class DynamicBinding{
    public static void main(String[] args){
    A a = new B();//a的编译类型是 A，运行类型是B
    System.out.println(a.sum());
    System.out.println(a.sum1());
    }

}
class A{  //父类
    public int i = 10;

    public int sum(){
        return getI() + 10;
    }
    
    public int sum1(){
        return i + 10;
    }
    
    public int getI(){
        return i;
    }
}
class B extends A{  //子类
    public int i = 20;
    
    //public int sum(){
    //    return i + 10;
    //}
    
    //public int sum1(){
    //    return i + 10;
    //}
    
    public int getI(){
        return i;
    }
}

此时结果为30，20。

对于30，因为子类中没有sum()方法，所以会去父类中调用sum()方法，调用方法中的return有getI()方法，因为当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定，此时对象的运行类型是B，所以调用B类中的getI()方法，返回20，加上10，得到30。

对于20，因为子类中没有sum1()方法，所以会去父类中调用sum1()方法，调用方法中有变量i，因为当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用，所以使用A类中声明的i=10，加上10，等于20。

（5）多态的应用

① 多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。

实例：现有一个继承结构如下，要求创建1个Person对象，2个Student对象和2个Teacher对象，统一放在数组中，并调用say方法。

//Person类
public class Person {
    private String name = "li";
    private int age = 23;

    public Person() {
    }

    public Person(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;
    }
    public String say(){
        return name + "\t" + age;
    }
}

//Student类
public class Student extends Person {
    private double score;

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

    public double getScore() {
        return score;
    }

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

    @Override
    public String say() {
        return super.say() + "\t" + score;
    }
    public void study(){
        System.out.println("学生" + getName() + "正在听课...");
    }
}

//Teacher类
public class Teacher extends Person{
    private double sal;

    public Teacher(String name, int age, double sal) {
        super(name, age);
        this.sal = sal;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    @Override
    public String say() {
        return super.say() + "\t" + sal;
    }
    public void teach(){
        System.out.println("老师" + getName() + "正在讲课...");
    }
}

//主类
public class PolyArray {
    public static void main(String[] args) {
        Person[] persons = new Person[5];
        persons[0] = new Person("hack",30);
        persons[1] = new Student("jack1",31,60);
        persons[2] = new Student("jack2",35,80);
        persons[3] = new Teacher("mark1",50,9000);
        persons[4] = new Teacher("mark2",55,10000);
        for (int i = 1; i < persons.length; i++) {
            System.out.println(persons[i].say());
        }
    }
}

如何调用子类特有的方法，比如Teacher有一个teach，Student有一个study，怎么调用？

使用向下转型即可。

//在主类for循环内加如下代码即可
if (persons[i] instanceof Student) {
    Student student = (Student)persons[i];
    student.study();
    //也可以写成  ((Student)persons[i]).study();
}else if (persons[i] instanceof Teacher) {
    ((Teacher) persons[i]).teach();
}

② 多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型。

a 定义员工类Employee，包含姓名和月工资【private】，以及计算年工资getAnnual的方法。普通员工和经理继承了员工，经理类多了奖金bonus属性和管理manage方法，普通员工类多了work方法，普通员工和经理类要求分别重写getAnnual方法；

b 测试类中添加一个方法showEmpAnnual(Employee e)，实现获取任何员工对象的年工资，并在main方法中调用该方法；

c 测试类中添加一个方法，testWork，如果是普通员工，则调用work方法，如果是经理，则调用manage方法。

//Employee类
public class Employee {
    private String name;
    private double sal;

    public Employee(String name, double sal) {
        this.name = name;
        this.sal = sal;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public String getAnnual(){
        return "姓名：" + name + " 薪水：" + 12*sal ;
    }

}

//Manager类
public class Manager extends Employee{
    private double bonus;

    public Manager(String name, double sal, double bonus) {
        super(name, sal);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    public void manage(){
        System.out.println("经理：" + getName() + "管理工作.");
    }

    @Override
    public String getAnnual() {
        return "经理" + super.getAnnual() + " 奖金" + bonus;
    }
}

//OrdEmployee类
public class OrdEmployee extends Employee{
    public OrdEmployee(String name, double sal) {
        super(name, sal);
    }

    public void work(){
        System.out.println("普通员工：" + getName() + "从事工作.");
    }

    @Override
    public String getAnnual() {
        return "普通员工" + super.getAnnual();
    }
}

//主类
public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        Manager manager = new Manager("lili",10000,20000);
        OrdEmployee ordEmployee = new OrdEmployee("xiaoli",7000);
        Employee employee1 = new Manager("haha",15000,25000);
        Employee employee2 = new OrdEmployee("xiaoha",8000);
        System.out.println(test.showEmpAnnual(manager));
        System.out.println(test.showEmpAnnual(ordEmployee));
        System.out.println(test.showEmpAnnual(employee1));
        System.out.println(test.showEmpAnnual(employee2));
        test.testWork(manager);
        test.testWork(ordEmployee);
        test.testWork(employee1);
        test.testWork(employee2);
    }
    public String showEmpAnnual(Employee e){
        return e.getAnnual();
    }
    public void testWork(Employee e) {
        if (e instanceof Manager) {
            Manager manager = (Manager) e;
            manager.manage();
        } else if (e instanceof OrdEmployee) {
            OrdEmployee ordEmployee = (OrdEmployee) e;
            ordEmployee.work();
        } else {
            System.out.println("错误");
        }
    }
}

五 Super关键字

1 基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器。

2 基本语法

① 访问父类的属性，但不能访问父类的private属性；

例如：super.属性名；

② 访问父类的方法，不能访问父类的private方法；

例如：super.方法名（参数列表）；

③ 访问父类的构造器；

例如：super（参数列表）；只能放在构造器的第一句，只能出现一句。

3 super给编程带来的便利/细节

（1）调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）；

（2）当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果（从子类逐层向上【父类】查找）！

（3）super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员，如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A（子类） -> B（父类） -> C（爷爷类）（先找父类，再找爷爷类，若都没有再找子类）；

4 super和this的比较

六方法重写（overwrite）

1 基本介绍

方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。

2 注意事项和使用细节

（1）子类的方法的形参列表，方法名称，要和父类方法的形参列表，方法名称完全一样；

（2）子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类；

比如：父类返回类型是Object，子类方法返回类型是String

（3）子类不能缩小父类方法的访问权限，但可以扩大。

3 方法重载和方法重写的区别和联系

七 Object类详解，垃圾回收机制

1 equals方法

（1）==和equals的对比

==是一个比较运算符：

① ==：既可以判断基本类型，又可以判断引用类型；

② ==：如果判断基本类型，判断的是值是否相等。例如：int i = 10; double d = 10.0;true

③ ==：如果判断引用类型，判断的是地址是否相等，及判断是不是同一个对象；

④ equals()：是Object类中的方法，只能判断引用类型；

⑤ 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer，String。

//Object类中的equals方法
//判断对象/地址是否相同
public boolean equals(Object obj) {
        return (this == obj);
}

//String类中的equals方法
//判断字符串的值是否一致
public boolean equals(Object anObject) {
        if (this == anObject) {
            return 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;
            }
        }
        return false;
}

//Integer类的equals方法
//判断传入的值是否相等
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

（2）equals（）方法练习题

Person p1 = new Person();
p1.name = "lyxlearn";

Person p2 = new Person();
p2.name = "lyxlearn";

system.out.println(p1 == p2);  // ==在此判断的是对象（地址），不同，false
system.out.println(p1.name.equals(p2.name));  //equals,因为p1.name是字符串，
//在Person类中重写了equals,判断的是字符串是否一样，同，true
system.out.println(p1.equals(p2));  //因为person没有重写equals方法，
//所以用的还是Object父类的该方法，所以判断的是地址，不同，false

String s1 = new String("asdf");

String s2 = new String("asdf");

system.out.println(s1.equals(s2)); //同上第二个
system.out.println(s1 == s2);//同上第一个

int it =65;
float fl = 65.0f;
System.out.println(it == fl);  //true 值一样
char ch1 = 'A'; char ch2 = 12;
System.out.println(it == ch1);  //字符的本质是数字，A字符对应的数字为65， true
System.out.println(12 == ch2);  //同上

String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1 == str2);  //判断地址，不同 true
System.out.println(str1.equals(str2));  //判断字符串是否一样，true
System.out.println("hello" == new java.sql.Date());  //类型不一致，直接false

2 hashCode方法

（1）语法

对象名.hashCode()；

一般通过将调用对象的内部地址转换成一个整数来实现的，注意不能等价于地址。

（2）注意细节

① 提高具有哈希结构的容器的效率；

② 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的；

③ 两个引用，如果指向的是不同对象，则哈希值是不一样的；

④ 哈希值主要是根据地址来的，不能完全将哈希值等价于地址；

⑤ 在集合中，hashCode如果需要的话，也会重写。

3 toString方法

（1）基本介绍

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

//Object类中的toString方法
//getClass().getName():全类名
//Integer.toHexString(hashCode()): 哈希值的十六进制

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

子类中往往重写toString方法（快捷键 alt + insert 选择toString后勾选即可），用于返回对象的属性信息，在重写了toString方法后，打印对象或者拼接对象时，都会自动调用该对象的toString形式。

当直接输出一个对象时，toString方法会被默认的调用。

public class ToString_ {
    public static void main(String[] args) {
        Monster monster = new Monster("小银角", 200, "巡山的");
        System.out.println(monster.toString());
        System.out.println(monster);
    }
}
class Monster{
    private String name;
    private int age;
    private String job;

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

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

4 finalize方法

（1）当对象被回收时，系统自动调用该对象的finalize方法，子类可以重写该方法（比如释放资源，数据库链接等，若不重写则直接调用父类Object的finalize方法），做一些释放资源的操作；

（2）什么时候被回收：当某一个对象没有任何引用时，则jvm就认定这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，就先调用finalize方法；

（3）垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc（）主动除法垃圾回收机制（不能保证一定，只是很大概率，因为垃圾回收机制可能在忙别的）。

八断点调试（debug）

1 一个实际需求

（1）断点调试可以在一步一步的看源码执行的过程，从而发现错误所在；

（2）在断点调试过程中是运行状态，是以对象的运行类型来执行的。

2 介绍

（1）断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看到各个变量当前的值，如果出错的话，调试到出错的代码行即显示错误，停下，进行分析从而找到这个Bug；

（2）断点调试是程序员必须掌握的技能；

（3）断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的java水平。

3 快捷键

（1）F7（跳入：跳入方法内）

① 例子：Array.sort(arr)；//其中arr是一个数组，对数组进行排序

就可以通过F7进入sort方法内，查看相关源码

② 若无法跳入有以下两种解决方法

a 使用alt + shift +F7进行强制跳入

b 通过设置（推荐）

（2）F8（跳过：逐行执行代码）

（3）shift + F8（跳出方法）

通常和F7跳入方法内连用，用于跳出方法。

（4）F9（resume：执行到下一个断点）

注意：断点支持在运行过程中动态地下断点。

F9尝使用于不在于两断点之间地内容，直接执行到下一个断点，不再逐行执行。

4 运行模块图

九项目

1 零钱通（面向过程编程）

（1）完成显示菜单，并可以选择菜单，给出相应的提示；
（2）完成零钱通明细
三种方案①数组 ②对象 ③String拼接
（3）完成收益入账
（4）完成消费
（5）完成退出，改进代码
① 用户输入4退出时，给出提示"是否退出(y/n)"，必须输入正确的y/n，否则循环输入指令，直到输入y或者n。
②在收益入账和消费时，判断金额是否合理，并给出相应的提示。

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

public class SmallChangeSys {
    //1.完成显示菜单，并可以选择菜单，给出相应的提示；
    //2.完成零钱通明细
    //三种方案（1）：数组（2）：对象（3）String拼接
    //3.完成收益入账
    //4.完成消费
    //5.完成退出，改进代码
    //(1)用户输入4退出时，给出提示"是否退出(y/n)"，必须输入正确的y/n,
    // 否则循环输入指令，直到输入y或者n。
    //(2)在收益入账和消费时，判断金额是否合理，并给出相应的提示。
    //(3)将面向过过程的代码改成面向对象的方法，编写SmallChangeSysOOP.java，
    //完成改进后的1，2，3，4，5各个功能
    //并使用SmallChangeSysApp.java，创建对象，调用方法，完成测试。
    public static void main(String[] args) {
        //定义相关变量
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);
        String choseNum = "";

        //2.完成零钱通明细
        String details ="--------------零钱通明细--------------";

        //3.完成收益入账
        //定义新的变量（根据功能），完成功能驱动程序员增加新的变化和代码
        double money = 0;//收入
        double balance = 0;//余额
        Date date = null;// date 是 Java.util.Date 的类，表示日期
        //将date转换为中国常用的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //4.完成消费
        //定义新变量，保存消费的原因
        String note ="";

        //5.退出
        //定义新变量，保存退出的标记
        String choice = "";
        do {
            System.out.println("\n==============零钱通菜单==============");
            System.out.println("\t\t\t" + "1 零钱通明细");
            System.out.println("\t\t\t" + "2 收益入账");
            System.out.println("\t\t\t" + "3 消费");
            System.out.println("\t\t\t" + "4 退\t出");

            System.out.print("请选择(1-4):");
            choseNum = scanner.next();

            //使用switch分支控制
            switch (choseNum){
                case "1":
                    System.out.println(details);
                    break;
                case "2":
                    System.out.print("收益入账金额：");
                    money = scanner.nextDouble();
                    //money的范围应该校验，不可能为负数
                    if (money <= 0){
                        System.out.println("收益入账金额输入有误(小于等于0)");
                        break;
                    }
                    balance +=money;
                    date = new Date();//获取当前时间，需要SimpleDateFormat转换格式
                    //拼接收益入账信息到 details
                    details += "\n收益入账\t+" + money +"  "+ sdf.format(date) +"   余额：" + balance;
                    break;
                case "3":
                    if (balance == 0){
                        System.out.println("余额为0");
                        break;
                    }
                    System.out.print("消费金额：");
                    money = scanner.nextDouble();
                    //money的范围应该校验，不能超过余额balance
                    if (money <= 0 || money > balance){
                        System.out.println("消费金额有误(未在0-" + balance + "之间)");
                        break;
                    }
                    System.out.println("消费说明:");
                    note = scanner.next();
                    balance -= money;
                    date = new Date();
                    //拼接消费信息到 details
                    details += "\n"+ note + "\t-" + money +"  "+ sdf.format(date) +"   余额：" + balance;
                    break;
                case "4":
                    while (true){
                        //y表示是，n表示否
                        System.out.print("是否退出（y/n）:");
                        choice = scanner.next();
                        if ("y".equals(choice) ||"n".equals(choice)){
                            break;
                        } else {
                            System.out.println("输入有误，请重新输入(y/n)");
                        }
                        //第二个方案，将两个功能写在一段代码里，即判断①是否输入的为y/n；②输入的是y还是n
//                        if ("y".equals(choice)){
//                            loop = false;
//                            break;
//                        }else if ("n".equals(choice)){
//                            System.out.println("程序继续");
//                            break;
//                        }else {
//                            System.out.println("输入有误，请重新输入(y/n)");
//                        }
                    }
                    if ("y".equals(choice)){
                        loop = false;
                    }else {
                        System.out.println("程序继续");
                    }
                    break;
                default:
                    System.out.println("输入号码有误，请重新输入(1-4).");
            }
        }while (loop);
        System.out.println("使用愉快，欢迎下次登陆~");
    }
}

2 零钱通（面向对象编程）

将面向过过程的代码改成面向对象的方法，编写SmallChangeSysOOP.java，完成改进后的1，2，3，4，5各个功能，并使用SmallChangeSysApp.java，创建对象，调用方法，完成测试。

//SmallChangeSysOOP类
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class SmallChangeSysOOP {
    //定义相关变量
    private boolean loop = true;
    private Scanner scanner = new Scanner(System.in);
    private String choseNum;

    //2.完成零钱通明细
    private String details ="--------------零钱通明细--------------";

    //3.完成收益入账
    //定义新的变量（根据功能），完成功能驱动程序员增加新的变化和代码
    private double money;//收入
    double balance;//余额
    private Date date;// date 是 Java.util.Date 的类，表示日期
    //将date转换为中国常用的格式
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    //4.完成消费
    //定义新变量，保存消费的原因
    private String note;

    //5.退出
    //定义新变量，保存退出的标记
    private String choice;

    public boolean isLoop() {
        return loop;
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    //1.完成显示菜单，并可以选择菜单，给出相应的提示；
    public void ShowMenu(){
        do {
            System.out.println("\n==============零钱通菜单(OOP)==============");
            System.out.println("\t\t\t" + "1 零钱通明细");
            System.out.println("\t\t\t" + "2 收益入账");
            System.out.println("\t\t\t" + "3 消费");
            System.out.println("\t\t\t" + "4 退\t出");
            System.out.print("请选择(1-4):");
            choseNum = scanner.next();
            switch (choseNum) {
                case "1":
                    ShowDetails();
                    break;
                case "2":
                    CompleteEntry();
                    break;
                case "3":
                    CompleteConsume();
                    break;
                case "4":
                    ExitSys();
                    break;
                default:
                    System.out.println("输入号码有误，请重新输入(1-4).");
            }
        }while (loop);
    }

    //2.完成零钱通明细
    public void ShowDetails(){
        System.out.println(details);
    }

    //3.完成收益入账
    public void CompleteEntry(){
        System.out.print("收益入账金额：");
        money = scanner.nextDouble();
        //money的范围应该校验，不可能为负数
        if (money <= 0){
            System.out.println("收益入账金额输入有误(小于等于0)");
            return;
        }
        balance +=money;
        date = new Date();//获取当前时间，需要SimpleDateFormat转换格式
        //拼接收益入账信息到 details
        details += "\n收益入账\t+" + money +"  "+ sdf.format(date) +"   余额：" + balance;
    }

    //4.完成消费
    public void CompleteConsume(){
        if (balance == 0){
            System.out.println("余额为0");
            return;
        }
        System.out.print("消费金额：");
        money = scanner.nextDouble();
        //money的范围应该校验，不能超过余额balance
        if (money <= 0 || money > balance){
            System.out.println("消费金额有误(未在0-" + balance + "之间)");
            return;
        }
        System.out.println("消费说明:");
        note = scanner.next();
        balance -= money;
        date = new Date();
        //拼接消费信息到 details
        details += "\n"+ note + "\t-" + money +"  "+ sdf.format(date) +"   余额：" + balance;
    }
    //5.完成退出
    public void ExitSys(){
        while (true){
            //y表示是，n表示否
            System.out.print("是否退出（y/n）:");
            choice = scanner.next();
            if ("y".equals(choice) ||"n".equals(choice)){
                break;
            } else {
                System.out.println("输入有误，请重新输入(y/n)");
            }
            //第二个方案，将两个功能写在一段代码里，即判断①是否输入的为y/n；②输入的是y还是n
//                        if ("y".equals(choice)){
//                            loop = false;
//                            break;
//                        }else if ("n".equals(choice)){
//                            System.out.println("程序继续");
//                            break;
//                        }else {
//                            System.out.println("输入有误，请重新输入(y/n)");
//                        }
        }
        if ("y".equals(choice)){
            loop = false;
        }else {
            System.out.println("程序继续");
        }
    }
}

//SmallChangeSysApp测试类

public class SmallChangeSysApp {
    public static void main(String[] args) {
        SmallChangeSysOOP smallChangeSysOOP = new SmallChangeSysOOP();

            smallChangeSysOOP.ShowMenu();

        System.out.println("使用愉快，欢迎下次登陆~");
    }
}

知识点

1 继承设计的基本思想

父类的构造器完成父类属性的初始化，子类的构造器完成子类属性的初始化。

2 查看JDK源码

放在想要查看的方法上面直接ctrl+B即可（这是我的快捷键）无快捷键可以右击，选择GO TO -> Declaration or Usages即可查看源码。

若无法查看，可能是因为jdk包没有导入，可以File -> Project Structure -> SDKs -> Sourcepath，点击右侧的加号，选择自己安装jdk的路径，导入src.zip和javafx-src.zip即可。

3 得到当前日期

先导入包：import java.util.Date

Date date = new Date; //此时得到的日期格式是外国格式

导入包：import java.text.SimpleDateFormat

然后创建对象、转换日期格式：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//注意大小写

sdf.format(date);即可转换成功。

一颗毛李子

关注

1
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
B站韩顺平java学习笔记（七）--面向对象编程（中级）章节

一、IDEA使用1、IDEA使用技巧和经验（1）设置字体菜单 file -> settings（2）字符编码设置2、IDEA常用快捷键（1）删除当前行，ctrl + y （2）（3）（4）二、包三、访问修饰符四、OOP三大特征（封装，继承和多态）五、Super关键字六、方法重写（overwrite）七、Object类详解，垃圾回收机制...
复制链接

扫一扫