Java 面向对象 | 详细知识图谱式讲解

☢Java入门

基础知识：了解 Java 基本语法、面向对象编程（OOP）概念、流程控制语句、数据类型、方法等基础知识。可以通过 Java 编程入门教程、Java 编程思想等书籍进行学习。
面向对象编程：深入学习 OOP 概念，包括封装、继承、多态、接口等。掌握设计模式、反射机制等高级特性。可以参考《Effective Java》等书籍进行学习。
Java 核心类库：熟练掌握 Java 核心类库，包括集合框架、IO、并发、网络编程等。可以参考《Java 核心技术》等书籍进行学习。
Web 开发：学习 Java Web 开发相关知识，包括 Servlet、JSP、MVC 模式、Spring 框架、Hibernate 等。可以参考《Spring 实战》、《Hibernate 实战》等书籍进行学习。
数据库编程：学习使用 Java 连接数据库、操作数据库等知识。可以学习 MySQL、Oracle、MongoDB 等常用数据库的使用。
其他领域：学习 Android 开发、Java 大数据开发、Java 游戏开发等其他领域的知识

☢Java面向对象

面向过程POP(C语言)

面向过程是自上而下的设计语言，先定好框架，再增砖添瓦。通俗点，就是先定好main()函数，然后再逐步实现mian()函数中所要用到的其他方法

面向对象OOP(c++，c#，java，delphi)

面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的对象，其基本思想是一切皆对象，是一种自下而上的设计语言，先设计组件，再完成拼装

☢构造方法

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

作用：完成对象数据的初始化

格式：

public class 类名{
	修饰符 类名(参数){
	……
	}
}

无参构造方法

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

带参构造方法

//带参构造方法
public Student(String name, int age) {
    this.name = name;
    this.age = age;
}

构造方法调用

//创建对象，实例化对象
Student student = new Student();    //调用无参构造方法

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

final Student student2 = new Student("wei",18); //调用带参构造方法

创建Student类

package itiheima_02;

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

    //定义成员方法
    public void show() {
        System.out.println("name:" + name + "," + "age:" + age);
    }

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

    //带参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

创建StudentDemo测试类

package itiheima_02;

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象，实例化对象
        Student student = new Student();    //调用无参构造方法
        student.show(); //name、age未赋值所以输出结果为空  name:null,age:0

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

        final Student student2 = new Student("wei",18); //调用带参构造方法
        student2.show();    //name:wei,age:18
    }
}

💨成员方法和构造方法的区别

构造方法：

没有返回值类型，没有return，方法名和类名相同
如果没有写构造方法，系统会自动添加一个无参构造方法

成员方法：

有返回值类型，若有返回值类型为空void,则可以不写return，成员方法名和类名不能相同
系统不会自动添加成员方法

总结：成员方法有返回值，构造方法无返回值

package itiheima_05;

public class TEST {
    int age = 18;
    String name = "WEi_SHUO";

    //无参构造方法，没有写构造方法，系统会自动添加一个无参构造方法
    public TEST() {
    }

    //带参构造方法
    public TEST(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //成员方法
    public void show(){
        //局部变量（成员方法中的变量）
        int age = 18;
        System.out.println(age);
    }
}

☢类/方法

💨类

类的组成：属性和行为属性：类中通过成员变量体现行为：类中通过成员方法体现

Java中的类是通过class关键字来定义

[修饰符] class 类名 [extends 父类名] [implements 接口名]{

// 类体，包括类的成员变量和成员方法

}

💨方法

有参和无参

无参方法

 public static void wucan(){ 
        System.out.println("无参方法");
}

带参方法

 public static void sum(int a,int b){ 
        System.out.println("两数相加结果"+a+b); 
}

有无返回值

有返回值

public static int sum(int a,int b){
        return a+b;
}

无返回值

public static void sum(int a,int b){
       System.out.println("无返回值"); 
}

💨对象

对象是类的一个实例，通过new这个关键字使用构造方法创建当前类的对象

格式：类名对象名 = new 类名();

Phone p = new Phone();

对象的使用使用成员变量：

格式：对象名.变量名
p.brand

使用成员方法

格式：对象名.方法名
p.call()

创建对象步骤：

声明：声明一个对象，包括对象名称和对象类型
实例化：使用关键字 new 来创建一个对象
初始化：使用 new 创建对象时，会调用构造方法初始化对象

创建Phone类

package itiheima_01;

public class Phone {
    //成员变量
    String brand;
    int price;

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

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

创建PhoneDemo测试类

package itiheima_01;

public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new Phone();
		System.out.println(p);  //itiheima_01.Phone@1b6d3586  内存地址
        
        //成员变量赋值
        p.brand="小米";
        p.price=1999;

        //输出成员变量
        System.out.println(p.brand);
        System.out.println(p.price);
        /*
        执行结果：
        小米
        1999
        */

        //调用成员方法
        p.call();
        p.SendMessage();
        /*
        执行结果：
        打电话
        发短信
        */

    }
}

☢变量

💨成员变量/局部变量/成员方法

成员变量（全局变量）：类中方法外的变量
局部变量：成员方法中的变量
成员方法：类中定义的方法

//特殊的成员方法：main():
public static void main(String[] args){
			//特定的功能
}

//一般的成员方法：
public 返回值类型 方法名(形式参数列表){
        //方法体;(特定功能的代码)
        return 返回值;
}

💨静态变量/实例变量

静态变量静态变量用 static字符修饰，随着类的加载而加载，静态变量存放在方法池中的静态区，可以直接通过"类名.变量名直接"调用，也可以通过类的对象调用
实例变量实例变量相当于该类的属性，需要 "new对象 "才能被调用。而且该变量不常驻内存，当这个类不再被使用时会java回收机制所释放
区别
存储区域不同：静态变量存储在静态存储区域，实例变量存储在堆中，会被释放
生命周期不同：静态变量在类启动时就分配指定内存；实例变量在被对象调用后才分配内存，调用结束时内存释放
静态变量与类相关，实例变量与对象相关

实例变量在被对象调用后才分配内存，调用结束时内存释放；所以random两次调用后任然为3
静态变量在类启动时就分配指定内存；所以第二次调用之后为4

public class TEST {
        private static int staticInt = 2;//静态变量
        private int random = 2;//实例变量

        public TEST() {		//TEST无参构造方法
            staticInt++;
            random++;
            System.out.println("staticInt = "+staticInt+"  random = "+random);
        }

        public static void main(String[] args) {	//main方法：特殊的成员方法
            //定义test变量，通过new关键字创建TEST对象，进而调用TEST无参构造方法
            TEST test = new TEST();
            TEST test2 = new TEST();
        }

}

/*
输出结果：
staticInt = 3  random = 3
staticInt = 4  random = 3
*/

静态代码块（静态代码块>构造代码块>构造函数>普通代码块）静态代码块写在类里面的时候，优先于类的加载、执行，且只会被加载一次

public class Car {
    static String color;
    // 下面是一个静态代码块
    static {
        color = "red";
        System.out.println("这辆车的颜色是" + color);
    }
}

☢封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过成员变量private，提供对应的get/set方法

通过方法来控制成员变量的操作，提高了代码的安全性
代码用方法封装，提高代码的复用性

语法格式：

public class Person {
    private String name;
    private int age;
}

☢继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

提高代码复用性和维护性
子类和父类产生关系，耦合性增强父类变化子类也需要变化

继承格式：

public class 子类名 extend 父类名{}

继承中子类特点

子类可以有父类的内容
子类也可以有特有的内容

☢多态

同一个对象，在不同时刻表现出来的不同形态多态的前提和体现

继承/实现关系
方法重写
父类引用指向子类对象

多态访问中成员访问的特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边
原因：成员方法有重写，成员变量没有

Animal类

package itiheima_02;

public class Animal {

    public int age =40;

    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat类

package itiheima_02;

public class Cat extends Animal{

    public int age=20;
    public int weight=10;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

AnimalDemo测试类

package itiheima_02;


    /*
    多态前提和体现
    继承/实现关系
    方法重写
    父类引用指向子类对象
    */

public class AnimalDemo {
    public static void main(String[] args) {
        //父类引用指向子类对象——多态

        Animal animal = new Cat();

        //多态方式访问成员变量：编译看左边，运行看左边
        System.out.println(animal.age);

        //多态方式访问成员方法：编译看左边，运行看右边
        animal.eat();


    }
}

💨多态中的转型

向上转型从子到父父类引用指向子类对象
向下转型从父到子父类引用转为子类对象

向下转型解决了多态的弊端：不能访问子类的特有功能

Animal类

package itiheima_02;

public class Animal {

    public int age =40;

    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat类

package itiheima_02;

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

AnimalDemo测试类

package itiheima_02;


/*
- 向上转型
  从子到父
  父类引用指向子类对象

- 向下转型
  从父到子
  父类引用转为子类对象
*/

public class AnimalDemo {
    public static void main(String[] args) {
        /*
        多态
        向上转型:
        从子到父
        父类引用指向子类对象
        */
        Animal animal = new Cat();  //向上转型
        //多态访问成员方法：编译看左边，执行看右边
        animal.eat();   //猫吃鱼
//        animal.playGame();    Error,因为编译看左边，左边Animal没有playGame方法

        //使用Cat中playGame方法有两种方法：

        //方式一：
        //创建Cat类对象
        Cat cat = new Cat();
        cat.eat();  //猫吃鱼
        cat.playGame(); //猫捉迷藏


        //方式二：
        /*
        多态
        向下转型
        从父到子
        父类引用转为子类对象
        */
        Cat cat1 = (Cat) animal;
        cat1.eat();     //猫吃鱼
        cat1.playGame();    //猫捉迷藏

        //向下转型解决了多态的弊端：不能访问子类的特有功能

    }
}

☢String概述

String构造方法方法名说明public String()创建一个空白字符串对象，不会有任何内容public String(char[] chs)根据字符数组的内容，来创建字符串对象public String(byte[] bys)根据字节数组的内容，来创建字符串对象String s = “abc”;直接赋值的方式创建字符创对象，内容就是abc

💨StringBulider概述

StringBulider构造方法方法名说明public StringBulider()创建一个空白可变字符串对象，不含有任何内容public StringBulider(String str)根据字符串的内容，来创建可变字符串对象 StringBulider添加/反转方法方法名说明public StringBulider append(任意类型)添加数据，并返回对象本省public StringBulider reverse()返回相反的字符序列

💨String和StringBulider相互转换

StringBulider转换String
通过toString()可以实现

public string toString();
        //StringBulider转换String
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("hello");
        String s = stringBuilder.toString();
        System.out.println(s);  //hello

String转换StringBulider
通过构造方法可以实现

public StringBulider(String s);
        //String转换StringBulider
        String s = "hello";
        StringBuilder stringBuilder = new StringBuilder(s);
        System.out.println(stringBuilder);      //hello

集合框架

集合：

Collection集合：单列集合、类似数组，每个元素只包含一个值
List集合：可重复集合
ArrayList集合
LinkedList集合
Set集合：不可重复集合
HashSet集合
TreeSet集合
Map集合：双列集合、类似二维数组，每个元素包含键值对
HashMap集合

💨Collection集合

概述：

单例集合的顶层接口，表示一组对象，这些对象成为Collection的元素
JDK不提供接口的任何直接实现，提供更具体的子接口Set/List实现

创建Collection集合对象

多态方式
具体实现类ArrayList

💨ArrayList集合

ArrayList集合构造方法和添加方法

方法名	说明
public ArrayList()	创建一个空的集合对象
public boolean add(E e)	将指定的元素追加到此集合末尾
public boolean add(int index,E element)	在此集合的指定位置插入指定元素

        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("hello");
        arrayList.add("world");
        arrayList.add(1,"java");
        System.out.println(arrayList);      //[hello, java, world]

ArrayList集合常用方法

方法名	说明
public boolean remove(Object)	删除指定元素，返回删除是否成功
public E remove(int index)	删除指定索引的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，放回被修改的元素
public E get(int index)	放回指定索引处的元素
public int size()	放回集合中的元素的个数

☢权限修饰符

作用：用于控制被修饰变量，方法，类的可见范围访问权限修饰符: 由小到大—private –default—protected—public

💨private(私有)

private关键字是权限修饰符，修饰成员变量、成员方法
保护成员变量、成员方法不被别的类使用，被private修饰的成员变量、成员方法只能在本类中访问

private关键字修饰的成员变量，如果被其它类使用，需要响应的操作

提供"get变量名()"方法，用于获取成员变量的值，方法用public修饰
提供"set变量名(参数)"方法，用于获取成员变量的值，方法用public修饰

Student类

//Student类
public class Student {
    //成员变量：类中，方法外
    String name;
    private int age;

    //提供get、set方法设置、获取值


    public int getAge() {
        return age;
    }

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

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo测试类

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //给成员变量赋值
        s.name="wei_shuo";
        s.setAge(18);	//使用setAge设置值、getAge可获取值

        //调用show方法
        s.show();
    }
}

💨default(默认)

背景：接口在Java中定义之初，有一个缺点，如果定义了一个接口，接口中又定义了N个方法，那么某个具体的类在实现该接口时，需要实现接口中的所有方法，不管是否需要用到接口中的方法。如果接口中的某个方法被default关键字修饰了，那么具体的实现类中可以不用实现方法

default关键字大部分都应用于接口
通过default关键字定义的方法，集成该接口的方法不需要去实现该方法

Person接口

public interface Person {
    default String getName(){
        return "hello world";
    }
}

Student实现类（实现该接口的类不需要去实现该方法）

class Student implements Person {
    //可以不用实现show()方法
}

main方法

public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }

💨protected(保护)

Java 中的 protected 是一种访问修饰符，用于限制对类成员的访问。被声明为 protected 的类成员可以被其同一包中的其他类访问，以及该类的子类中访问。具体来说，如果一个类成员被声明为 protected，那么该成员可以在以下情况下被访问：

从同一包中的其他类访问该成员。
从子类中访问该成员。

在其他情况下，无法直接访问 protected 成员。需要通过子类来访问该成员，或者通过该类的公共方法来访问。需要注意的是，protected 成员与 private 成员的区别在于，protected 成员可以被该类的子类访问，而 private 成员则不能。而与 public 成员相比，protected 成员的访问权限更加受限，只能在同一包中或子类中访问

💨public(公开)

在 Java 中，public 是一种访问修饰符，用于声明一个类、方法或变量可以被任何类访问。被声明为 public 的类、方法或变量可以在任何地方被访问，包括其他包中的类。具体来说，如果一个类、方法或变量被声明为 public，那么它可以在以下情况下被访问：

从任何其他类中访问该类、方法或变量。
从该类所在的包中的任何其他类访问该类、方法或变量。
从任何其他包中的类访问该类、方法或变量，但需要通过完全限定的类名（包括包名和类名）来访问。

需要注意的是，public 成员的访问权限最大，但是为了保证程序的封装性和安全性，不建议将所有类、方法或变量都声明为 public。通常情况下，只有那些需要在不同的包或类之间共享的元素才会被声明为 public。而对于仅在本类或包中使用的元素，应该将其声明为 private 或 protected

☢状态修饰符

💨final

final：final关键字是最终的意思，可修饰成员变量，成员方法，类特点：

修饰方法：表名改方法是最终方法，不能被重写
修饰变量：表名该变量是常量，不能被再次赋值
修饰类：表名该类是最终类，不能被继承

💨static

☢抽象修饰符

💨abstract

抽象类和抽象方法必须使用abstract关键字修饰

//抽象类
public abstract class 类名{};
//抽象方法
public abstract void eat();

抽象类不一定有抽象方法，有抽象方法一定是抽象类
抽象类实例化：参照多态方式，通过子类对象实例化（抽象类多态）
抽象类的子类：要么重写抽象类中所有抽象方法；要么子类是抽象类

☢关键字

💨static

static关键字是静态的意思，可以修饰成员方法，成员变量特点：

被static修饰会被类的所有对象共享，可以使用类名调用，也可以使用对象名访问

Student类

//Student类
public class Student {
    //成员变量
    public String name;
    public int age;
    //被所有对象共享的成员使用static修饰
    public static String university;


    //成员方法
    public void show() {
        System.out.println(name + "," + age + "," + university);
    }
}

StaticDemo测试类

package itiheima_03;


public class StaticDemo {
    public static void main(String[] args) {
        //static修饰的成员变量可以通过对象名访问，也可以通过类名访问
        Student.university = "加里敦大学";

        //创建学生类对象
        Student s1 = new Student();
        //Student类中name、age、university使用public修饰所以可以使用  对象.成员变量名  访问赋值
        s1.name="yiyi";
        s1.age=18;
        s1.university="加里敦大学";    //对象名访问可行
        s1.show();

        Student s2 = new Student();
        s2.name="erer";
        s2.age=20;
       	s2.university="加里敦大学";      //对象名访问可行
        s2.show();

    }
}

/*
输出结果：
yiyi,18,加里敦大学
erer,20,加里敦大学
*/

静态变量: 随着类加载被分配在方法区的静态区域,内存中只有一个,被类的所有实例共享非静态变量: 被实例化之后才分配内存,分配在堆内存中的对象空间里面

static方法调用非静态变量的问题？

JVM加载顺序：

静态块(静态变量)——>成员变量——>构造方法——>静态方法静态代码块(只加载一次) 构造方法(创建一个实例就加载一次) 静态方法需要调用才会执行
本质： JVM加载顺序约定的，加载 static 方法的时候非静态方法还没初始化
static方法是静态方法，属于类的方法；非static方法，属于对象的方法
非static方法是要与对象关联在一起的，必须在创建出一个对象后，才可以通过这个对象调用非static方法；而static方法可以直接通过类名来调用，不需要创建对象
一个static方法被调用时，还可能没有创建任何实例对象，此时如果从static内部发出对非static方法的调用，非static方法是无法关联到对象的

package itiheima_03;

public class Student {
    static String name;	//静态name成员变量
    int age; //非静态age成员变量

    public static void show1(){	//静态show1方法
        System.out.println(name);
        //System.out.println(age); //报错，静态方法无法调用非静态变量
    }

    public void show2(){ //静态show2方法
        System.out.println(name+","+age);
    }
}

💨void

void是一种数据类型，Java的底层代码中，对应一个void类作用：说明该方法无返回值

💨main

main函数也叫作主函数，主函数是一个作为程序入口的静态函数，可以被JVM识别并自动加载

格式：

public static void main(String[] args){}

main：众多编程语言的通用名称，用于表示主方法的入口。main虽然不是关键字，但是会被JVM识别

String[] args 作用：接收键盘录入的数据，表示一个字符串数组

String[]表示的是字符串类型的数组
args表示的是传入的参数名
主方法main(String[] args)可以接收一个字符串类型的数组，数组名字为args

💨class

class 关键字用于创建一个类。Java运行的每一行代码都必须在一个类中。类应始终以大写首字母开头，并且Java文件的名称必须与类名称匹配。 Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建

💨this

this修饰的变量用于指代成员变量

方法的形参如果与成员变量同名
this关键字修饰的指的是成员变量，不带this关键字修饰的是方法形参
方法的形参与成员变量不同名
不带this修饰的变量指的是成员变量
this关键字：避免局部变量与成员变量同名，导致局部变量隐藏

this：代表所在类的对象引用(方法被哪个对象引用，this就代表哪个对象)

💨super

super：代表父类存储空间的标识（父类对象应用） this：代表本类对象引用

FU类

public class FU {
    int age =40;
}

ZI类

public class ZI extends FU{
    int age = 20;

    public void show(){
        int age = 30;
        //调用局部变量age
        System.out.println(age);
        //调用成员变量age
        System.out.println(this.age);
        //调用父类变量age
        System.out.println(super.age);
    }
}

Demo测试类

public class Demo {
    public static void main(String[] args) {
        ZI zi = new ZI();
        zi.show();
    }
}
 		/*
        输出结果：
        30
        20
        40
        */

💨extend

在 Java 中，extends 是一种关键字，用于表示一个类继承自另一个类。子类可以继承父类的属性和方法，并可以添加自己的属性和方法。

下面是一个简单的 Java 代码示例，演示了如何使用 extends 关键字创建一个子类，并继承父类的属性和方法：

public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal("Animal");
        animal.makeSound(); // 输出 "The animal makes a sound"
        
        Dog dog = new Dog("Fido");
        dog.makeSound(); // 输出 "The dog barks"
        System.out.println(dog.name); // 输出 "Fido"
    }
}

在上面的例子中，Animal 类是一个基类，Dog 类是一个继承自 Animal 类的子类。Dog 类继承了 Animal 类的 name 属性和 makeSound() 方法，并且通过 @Override 注解覆盖了 makeSound() 方法，使其输出狗叫的声音。在 Main 类中，我们创建了一个 Animal 对象和一个 Dog 对象，并调用它们的 makeSound() 方法和 name 属性。由于 Dog 继承自 Animal，所以它也继承了 name 属性，我们可以通过 dog.name 来访问它

💨implements

在 Java 中，implements 是一种关键字，用于表示一个类实现了一个或多个接口。通过实现接口，类可以获得接口中定义的方法和常量，并提供自己的实现。

下面是一个简单的 Java 代码示例，演示了如何使用 implements 关键字实现一个接口：

public interface Shape {
    double getArea();
    double getPerimeter();
}

public class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        System.out.println("Area of the circle: " + circle.getArea());
        System.out.println("Perimeter of the circle: " + circle.getPerimeter());
    }
}

在上面的例子中，Shape 接口定义了两个方法 getArea() 和 getPerimeter()，它们分别返回图形的面积和周长。Circle 类实现了 Shape 接口，并提供了自己的实现。在 Main 类中，我们创建了一个 Circle 对象，并调用它的 getArea() 和 getPerimeter() 方法，它们返回了圆的面积和周长。

需要注意的是，一个类可以实现多个接口，多个接口之间用逗号分隔。如果一个类实现了多个接口，它必须实现每个接口中定义的方法

💨interface

在 Java 中，interface 是一种特殊的抽象类，它只包含常量和抽象方法的声明。通过实现接口，类可以获得接口中定义的方法和常量，并提供自己的实现。

下面是一个简单的 Java 代码示例，演示了如何定义和实现一个接口：

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("The cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound(); // 输出 "The dog barks"
        
        Animal cat = new Cat();
        cat.makeSound(); // 输出 "The cat meows"
    }
}

在上面的例子中，Animal 接口定义了一个 makeSound() 方法，表示动物会发出声音。Dog 类和 Cat 类实现了 Animal 接口，并提供了自己的实现。在 Main 类中，我们创建了一个 Dog 对象和一个 Cat 对象，并将它们声明为 Animal 类型。由于 Dog 和 Cat 都实现了 Animal 接口，所以它们都有 makeSound() 方法。我们可以通过调用 dog.makeSound() 和 cat.makeSound() 来分别听到狗叫和猫叫的声音。

需要注意的是，接口中的方法默认是 public abstract 类型，常量默认是 public static final 类型，因此不需要显式地指定。接口不能包含构造方法，因为它们不会被继承

💨class

在 Java 中，class 是一种定义对象属性和行为的模板。类是面向对象编程的核心概念之一，它用于组织和封装数据和代码，以实现高内聚和低耦合的设计。

下面是一个简单的 Java 代码示例，演示了如何定义和使用一个类：

public class Car {
    private String make;
    private String model;
    private int year;
    
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }
    
    public void start() {
        System.out.println("The car is starting...");
    }
    
    public void stop() {
        System.out.println("The car is stopping...");
    }
    
    public void drive(int miles) {
        System.out.println("The car is driving " + miles + " miles...");
    }
    
    public String getMake() {
        return make;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getYear() {
        return year;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", "Camry", 2021);
        System.out.println("Make: " + car.getMake());
        System.out.println("Model: " + car.getModel());
        System.out.println("Year: " + car.getYear());
        car.start();
        car.drive(10);
        car.stop();
    }
}

在上面的例子中，我们定义了一个 Car 类，它有三个私有属性 make、model 和 year，以及三个公共方法 start()、stop() 和 drive()，用于启动、停止和驾驶车辆。我们还为每个属性提供了公共的 getter 方法，以便可以在外部访问它们的值。

在 Main 类中，我们创建了一个 Car 对象，并通过调用它的 getMake()、getModel() 和 getYear() 方法来获取车辆的制造商、型号和年份。我们还调用了 start()、drive() 和 stop() 方法来启动、驾驶和停止车辆。

需要注意的是，Java 中的类可以继承其他类，从而扩展已有的类，并在其基础上添加新的属性和方法。此外，类还可以实现接口，以获得接口中定义的方法和常量。通过使用类的继承和实现，可以实现代码的重用和多态

💨new

在 Java 中，new 是一种用于创建新对象的操作符。它可以在内存中分配一段新的空间，并返回一个指向该空间的对象引用。使用 new 操作符创建对象的过程称为实例化。

下面是一个简单的 Java 代码示例，演示了如何使用 new 操作符创建对象：

public class Car {
    private String make;
    private String model;
    private int year;
    
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }
    
    public void start() {
        System.out.println("The car is starting...");
    }
    
    public void stop() {
        System.out.println("The car is stopping...");
    }
    
    public void drive(int miles) {
        System.out.println("The car is driving " + miles + " miles...");
    }
    
    public String getMake() {
        return make;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getYear() {
        return year;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", "Camry", 2021);
        System.out.println("Make: " + car.getMake());
        System.out.println("Model: " + car.getModel());
        System.out.println("Year: " + car.getYear());
        car.start();
        car.drive(10);
        car.stop();
    }
}

在上面的例子中，我们使用 new 操作符创建了一个 Car 对象，并将它赋值给 car 变量。我们传递了三个参数 "Toyota"、"Camry" 和 2021 给 Car 类的构造函数，以初始化对象的属性。然后，我们可以使用 car 变量调用 getMake()、getModel() 和 getYear() 方法来获取对象的属性值，并调用 start()、drive() 和 stop() 方法来执行对象的行为。

需要注意的是，Java 中的 new 操作符只能用于实例化类的对象，而不能用于实例化接口或抽象类。此外，使用 new 操作符创建对象时，Java 会自动调用对象的构造函数来初始化对象的属性。如果类没有提供任何构造函数，则Java会自动提供一个默认的无参构造函数。如果需要提供特定的构造函数，则必须在类中显式地定义

☢自动装箱&拆箱

基本数据类型	包装类型
byte	java.Lang.Byte
short	java.Lang.Short
int	java.Lang.Integer
long	java.Lang.Long
float	java.Lang.Float
double	java.Lang.Double
boolean	java.Lang.Boolean
char	java.Lang.Character

装箱：基本类型——转换为——对应的包装类类型，一般使用方法valueOf（）方法实现拆箱：包装类类型——转换为——对应的基本数据类型，一般使用类中提供xxxValue（）方法实现

自动装箱

Integer i = 100； i += 200 // i = i + 200 ；i + 200 自动拆箱； i = i + 200 自动装箱

package itiheima_04;

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

        //装箱：基本类型转换为对应的包装类类型
        Integer i = Integer.valueOf(100);
        //自动装箱
        Integer ii = 100;   //省略了 Integer.valueOf(100);

        //拆箱：包装类类型转换为对应的基本数据类型
        ii = ii.intValue() + 200;
        //自动拆箱
        ii += 200;
    }
}

☢方法重写 & 方法重载

💨方法重写

子类出现和父类一模一样的方法声明
当子类需要父类的功能，而功能主体子类有自己的特有内容时，可以重写父类中的方法，这样即沿袭父类的功能，又定义了子类特有的内容
私有方法不能重写
子类方法访问权限不能比父类低（public > default > private）

Phone类

public class Phone {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

NewPhone类

public class NewPhone extends Phone{

    //重写父类方法
    @Override
    public void call(String name) {
        super.call(name);
        System.out.println("开启视频功能");
    }
}

Demo测试类

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

        Phone phone = new Phone();
        phone.call("weishuo");

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

        NewPhone newPhone = new NewPhone();
        newPhone.call("tian");
    }
}

💨方法重载

方法重载前提：方法名相同、参数列不同、与返回值无关

多个方法在一个类中
多个方法具有相同方法名
多个方法参数不相同、类型不同、数量不同

public class MethodDemo {
    public static void main(String[] args) {
        System.out.println(sum(1, 1));
        System.out.println(sum(1.1, 1.1));
        System.out.println(sum(1, 1, 1));
    }

    //需求1：求两个int类型数据和的方法
    public static int sum(int a, int b) {
        return a + b;
    }

    //需求2：求两个double类型数据和的方法
    public static double sum(double a, double b) {
        return a + b;
    }

    //需求3：求两个int类型数据和的方法
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
}

☢日期

💨Date

Date代表一个特定的时间，精确到毫秒

方法名	说明
public Date()	分配一个Date对象，并初始化，以便它代表被分配的时间
public Date(long date)	分配一个Date对象，将其初始化表示从标准基准时间起指定的毫秒数
piblic long getTime()	获取日期对象从1970年1月1日00:00:00到现在的毫秒值
public void getTime(long time)	设置时间，给的是毫秒值

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

        //public Date()
        Date d1 = new Date();
        System.out.println(d1); // Sun Nov 20 15:44:32 CST 2022

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

        //public Date(long date)
        long date2 = 1000*60*60;
        Date d2 = new Date(date2);
        System.out.println(d2); // Thu Jan 01 09:00:00 CST 1970
    }
}

💨SimpleDateFormat

SimpleDateFormat是一个具体类，用于区域设置敏感的方式格式化和解析日期

yyyy-MM-dd HH:mm:ss	常用的模式字母对应关系
y	年
M	月
d	日
H	时
m	分
s	秒

方法名	说明
SimpleDateFormat()	构建了一个 SimpleDateFormat，使用默认模式和日期格式
SimpleDateFormat(String pattern)	构建了一个 SimpleDateFormat使用给定的模式和默认的日期格式

格式化（Date——>String） public final String format(Date date) 将日期格式化成日期/时间字符串
解析（String——>Date） public Date parse(String source) 从给定的字符串开始解析文本以生成日期

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

        //格式化（Date——>String）
        Date date1 = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat();     //默认模式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    //自定义模式

        //格式化输出
        System.out.println(sdf1.format(date1));  //  22-11-20 下午4:03
        System.out.println(sdf2.format(date1));  //  2022-11-20 16:05:57


        //解析（String——>Date）
        String s = "2022-11-20 08:08:08";
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    //自定义模式
        System.out.println(sdf3.parse(s));  // Sun Nov 20 08:08:08 CST 2022
    }
}