Java 面向对象 | 详细知识图谱式讲解
wei_shuo的个人主页
wei_shuo的学习社区
Hello World ！
☢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
}
}
结语：创作不易，如果觉得博主的文章赏心悦目，还请——
点赞收藏⭐️评论冲冲冲