Java零基础入门笔记：(6)面向对象
前言
本笔记是学习狂神的java教程，建议配合视频，学习体验更佳。
【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili
第1-2章：Java零基础入门笔记：(1-2)入门（简介、基础知识）-CSDN博客
第3章：Java零基础入门笔记：(3)程序控制-CSDN博客
第4章：Java零基础入门笔记：(4)方法-CSDN博客
第5章：Java零基础入门笔记：(5)数组-CSDN博客
-
-
面向对象
什么是面向对象
面向过程和面向对象是两种不同的编程范式，它们在设计理念、代码组织方式以及解决问题的方法上存在显著差异。
- 面向过程是一种以函数为中心的编程思想，它将程序视为一系列过程的集合，每个过程通过函数实现特定的功能。在面向过程的编程中，开发者关注的是如何将问题分解为一系列步骤，并通过函数调用这些步骤来完成任务。代码通常围绕着数据的处理流程展开，通过函数的组合来实现复杂的功能。面向过程的编程范式强调的是“怎么做”，即通过一系列有序的步骤来解决问题。
- 面向对象则是一种以对象为中心的编程思想，它将程序视为一系列对象的集合，每个对象封装了数据和操作这些数据的方法。在面向对象的编程中，开发者关注的是如何将问题分解为对象，并通过对象之间的交互来完成任务。对象是数据和功能的封装体，通过类来定义对象的结构和行为。面向对象的编程范式强调的是“是什么”，即通过对象的属性和行为来描述问题和解决方案。
-
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
三大特性：封装、继承、多态
-
类是一个抽象的概念，它定义了一组具有相同属性和方法的对象的蓝图。类封装了数据（属性）和操作这些数据的行为（方法），提供了一种模板，用于创建具体的对象实例。通过类，可以定义对象的结构和行为，使得开发者能够以一种结构化的方式描述现实世界中的事物或概念。
对象是类的具体实例，它是根据类的定义创建的实体。对象具有类定义的属性和方法，并且可以存储具体的数据。每个对象都有自己的状态（属性值），但它们共享类定义的结构和行为。对象通过调用方法与外界交互，实现特定的功能。在程序运行时，对象是实际占用内存的实体，而类则是对象的抽象描述。
-
回顾方法
方法的定义
修饰符 返回值类型 方法名(...){
//方法体
return 返回值;
}package oop;
public class demo1 {
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名(...){
//方法体
return 返回值;
}
*/
//return 结束方法，返回一个结果！
public String sayHello(){
return "hello,world";
}
public void print(){
return;
}
public int max(int a,int b){
return a>b ? a : b; //三元运算符！
}
}
方法的调用
package com.oop.demo01;
//学生类
public class Student {
// //静态方法
// public static void say(){
// System.out.println("学生说话了");
// }
//非静态方法
public void say(){
System.out.println("学生说话了");
}
}
package com.oop.demo01;
public class Demo02 {
public static void main(String[] args) {
// //静态方法 static
// Student.say();
//非静态方法
//实例化这个类 new
//对象类型 对象名 = 对象值;
Student student = new Student();
student.say();
}
}
static不能直接调用无static的方法
public class Demo02 {
public static void main(String[] args) {
}
//static和类一起加载的
public static void a(){
// b(); // 会报错，因为static和类一起加载，而无static还没加载进来。
}
//类实例化 之后才存在
public void b(){
}
}
形参和实参
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数的类型要对应！
int add = Demo03.add(1,2);
System.out.println(add);
}
public static int add(int a,int b){
return a+b;
}
}
值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a); // 1
Demo04.change(a);
System.out.println(a); // 1
}
//返回值为空
public static void change(int a){ // 值传递，不改变值
a = 10;
}
}
引用传递
package com.oop.demo01;
//引用传递：对象
//对象，内存！
public class Demo05 {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name); //null
Demo05.change(perosn);
System.out.println(perosn.name); //SherlockMa
}
public static void change(Perosn perosn){ //引用传递,会改变值
//perosn是一个对象，指向的--->Perosn perosn = new Perosn(); 这是一个具体的人，可以改变属性！
perosn.name = "SherlockMa";
}
}
//定义了一个Perosn类，有一个属性：name
class Perosn{
String name; //null
}
类与对象的创建
这段代码演示了如何：
-
创建对象。
-
访问对象的属性（成员变量）。
-
初始化对象的属性。
-
打印对象的属性。
package oop.demo02;
public class Application {
public static void main(String[] args) {
Student xiaoming = new Student(); // 创建对象。
Student xiaohong = new Student();
System.out.println(xiaoming.name); // 未初始化，为Null
System.out.println(xiaoming.age);
xiaoming.name = "小明"; // 初始化对象的属性。
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xiaohong.name = "小明";
xiaohong.age = 3;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
}
}
null
0
小明
3
小明
3构造器详解
构造器是类中的一种特殊方法，主要用于在创建对象时初始化对象的属性值。它的名称必须与类名完全相同，且不能有返回值（包括void）。构造器的主要作用是为新创建的对象提供初始状态，确保对象在被使用之前处于一个有效的、有意义的状态。
当使用new关键字创建对象时，Java会调用相应的构造器来完成对象的初始化。如果没有显式定义构造器，Java会自动提供一个无参的默认构造器。然而，一旦类中定义了其他构造器（无论是否有参数），默认的无参构造器将不再自动生成，除非显式地声明它。
构造器可以是无参的，也可以是带参数的。无参构造器通常用于提供默认的初始化值，而带参数的构造器则允许在创建对象时直接传入特定的初始化值。通过this关键字，构造器可以访问对象的成员变量和方法，从而实现属性的初始化。
无参构造
下面的代码演示了一个无参构造方法，用于初始化 Person 类的对象。
-
this.name表示当前对象的name属性，"sherlockma"是一个字符串常量，表示默认的名称值。 -
当通过
new Person()创建对象时，构造方法会被调用，并将对象的name属性初始化为"sherlockma"。
package oop.demo02;
public class Person {
String name;
// 构造器的主要作用是：初始化对象的值
public Person(){ // 无参构造，new本质在调用构造方法
this.name = "sherlockma";
}
}
package oop.demo02;
public class Application {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
}
}
sherlockma有参构选和无参构造
下面的代码演示了一个带参数的构造器，允许在创建Person对象时传入一个名字作为初始化值。
-
参数
String name表示在创建对象时需要传入一个字符串作为名字。 -
this.name = name;将传入的参数值赋给对象的name属性。 -
带参数的构造器的作用是让对象在创建时能够根据传入的值进行初始化，从而提供更大的灵活性。
package oop.demo02;
public class Person {
String name;
// 构造器的主要作用是：初始化对象的值
public Person(){ // 无参构造，new本质在调用构造方法
this.name = "sherlockma";
}
public Person(String name){ // 定义有参构造之后，必须显示的定义一个无参的构造
this.name = name;
}
}
package oop.demo02;
public class Application {
public static void main(String[] args) {
Person person1 = new Person();
System.out.println(person1.name);
Person person2 = new Person("xiaoming");
System.out.println(person2.name);
}
}
sherlockma
xiaoming
-
构造器生成快捷键：alt+insert->选Constructor->选参数，其中选select None是无参构造器
-
创建对象内存分析
package com.oop.demo03;
public class Pet {
public String name;
public int age;
//无参构造
public void shout(){
System.out.println("叫了一声");
}
}
/*
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
Pet cat = new Pet();
}
*/
-
封装
封装是面向对象编程（OOP）中的一个核心概念，它指的是将对象的属性（成员变量）和行为（方法）组合到一个类中，并通过访问控制机制隐藏对象的内部实现细节，仅通过定义好的接口（方法）与外部交互。封装的目的是保护对象的内部状态，防止外部直接访问或修改对象的属性，从而确保对象的完整性和安全性。
在封装的设计中，类的成员变量通常被设置为私有（private），这意味着它们不能被类的外部直接访问。相反，类提供一组公共（public）的方法，称为“getter”和“setter”方法，用于获取和设置成员变量的值。这些方法不仅提供了对成员变量的访问，还可以在设置值时添加逻辑验证，确保数据的合法性。
例如，一个Person类可能包含一个age属性，该属性被设置为私有，以防止外部直接修改。通过提供一个setAge方法，可以在设置年龄时添加逻辑，如确保年龄不能为负数。这样，即使外部代码尝试设置一个不合理的值，对象的状态也能保持正确。
封装的另一个重要方面是隐藏实现细节。类的内部实现可以随时更改，但只要公共接口保持不变，外部代码就不需要修改。这种解耦使得代码更加灵活和可维护。封装不仅提高了代码的安全性和可靠性，还使得类的使用者无需了解类的内部实现，只需通过定义好的接口与对象交互，从而简化了编程的复杂性。
- alt+insert->选择getter and setter，快速生成get/set
下面的代码演示了使用get和set方法实现封装
package oop.demo02;
public class Student{
//属性私有
private String name; //名字
private int age; //年龄
//提供一些可以操作这个属性的方法！
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120 || age<0){ //不合法
this.age = 3;
}else {
this.age = age;
}
}
}package oop.demo02;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("SherlockMa");
System.out.println(s1.getName());
s1.setAge(-1); //不合法的
System.out.println(s1.getAge());
}
}-
继承
继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以自动获得父类的所有非私有属性和方法，并且可以在不重新编写代码的情况下扩展或修改父类的行为。这种机制不仅提高了代码的复用性，还体现了类之间的层次关系和“是一种”（is-a）的关系。
在继承中，父类定义了一组通用的属性和方法，而子类则可以继承这些通用特性，并根据需要添加新的属性和方法或覆盖父类的方法以实现特定的行为。例如，如果有一个Animal类，它可以定义一些通用的属性（如name）和方法（如eat()）。然后，Dog类可以继承Animal类，继承其通用特性，并添加特定于狗的行为（如bark()）。
继承的关键在于它允许开发者构建一个层次化的类结构。子类继承父类后，会自动获得父类的非私有成员（包括属性和方法），并且可以通过super关键字访问父类的构造方法和被覆盖的方法。这种层次化的结构使得代码更加模块化和易于维护，同时也使得类之间的关系更加清晰。
- 子类继承了父类，就会拥有父类的全部方法！
- 在Java中，所有的类，都默认直接或者间接继承Object
- JAVA中类只有单继承，没有多继承！一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子
Ctrl+H：打开继承树
下面的代码演示了Student继承Person类
package oop.demo02;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.say();
int money = s1.getMoney();
System.out.println(money);
}
}
package oop.demo02;
public class Person {
//public
//protected
//default
//private
private int money = 10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package oop.demo02;
public class Student extends Person{
}
-
super
super关键字在Java中用于显式地访问父类的成员，下面的代码演示了其使用方法
-
super.name访问的是父类Person中的name属性。由于Student类中定义了一个同名的私有变量name，它隐藏了父类的name属性。通过super关键字，可以显式访问父类的name属性。
package oop.demo02;
public class Person {
protected String name = "Person-name-sherlock";
public void print(){
System.out.println("Print:Person");
}
}
package oop.demo02;
public class Student extends Person{
private String name = "Student-name-sherlockma";
public void print(){
System.out.println("Print:Student");
}
public void test1(){
print(); //Student
this.print(); //Student
super.print(); //Person
}
public void test(String name){
System.out.println(name); //微笑
System.out.println(this.name); //weixiao
System.out.println(super.name); //liming
}
}
package oop.demo02;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test1();
student.test("sher");
}
}
Print:Student
Print:Student
Print:Person
sher
Student-name-sherlockma
Person-name-sherlock构造器
package oop.demo02;
public class Person {
public Person() {
System.out.println("Person no无参执行了");
}
public Person(String name) {
System.out.println("Person有参执行了");
}
protected String name = "Person-name-sherlock";
public void print(){
System.out.println("Print:Person");
}
}
package oop.demo02;
public class Student extends Person{
public Student() {
//隐敲代码：调用了父类的无参构选
super(); //调用父类的构造器，必须要在子类构造器的第一行
System.out.println("Student no无参执行了");
}
public Student(String name) {
super("name");
this.name = name;
System.out.println("Student有参执行了");
}
private String name = "Student-name-sherlockma";
public void print(){
System.out.println("Print:Student");
}
public void test1(){
print(); //Student
this.print(); //Student
super.print(); //Person
}
public void test(String name){
System.out.println(name); //微笑
System.out.println(this.name); //weixiao
System.out.println(super.name); //liming
}
}
package oop.demo02;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test1();
student.test("sher");
}
}
Person no无参执行了
Student no无参执行了
Print:Student
Print:Student
Print:Person
sher
Student-name-sherlockma
Person-name-sherlock-
方法重写
方法重写（Override）是面向对象编程中一个非常重要的概念，它允许子类根据自己的需求重新定义继承自父类的方法。方法重写的核心在于子类可以提供一个与父类同名、参数列表相同的方法，但实现细节可以完全不同。这种方式使得子类能够在继承父类行为的基础上，根据自身特点对某些行为进行定制或扩展。
重写:需要有继承关系，子类重写父类的方法!
1．方法名必须相同
2．参数列表列表必须相同
3．修饰符:范围可以扩大但不能缩小: public>Protected>Default>private
4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException ---> Exception(大)
重写，是方法的重写；子类的方法和父类必要一致;方法体不同!
为什么需要重写：父类的功能，子类不一定需要，或者不一定满足!Alt + Insert ; override;
-
静态的方法和非静态的方法区别很大！
- 静态方法：//方法的调用只和定义的数据类型有关
- 非静态：重写
有static（静态）
package oop.demo02;
//重写都是方法的重写，和属性无关
public class B {
public static void test(){
System.out.println("B=>test()");
}
}
package oop.demo02;
//继承
public class A extends B {
public static void test(){
System.out.println("A=>test()");
}
}
package oop.demo02;
public class Application {
public static void main(String[] args) {
A a = new A();
a.test(); //A
//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法
b.test(); //B
}
}A=>test()
B=>test()无static
package oop.demo02;
//重写都是方法的重写，和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}package oop.demo02;
//继承
public class A extends B {
public void test(){
System.out.println("A=>test()");
}
}package oop.demo02;
public class Application {
public static void main(String[] args) {
A a = new A();
a.test(); //A
//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法
b.test(); //B
}
}-
多态
方法多态是面向对象编程中的一个重要概念，它允许通过父类类型的引用调用子类的方法，从而使同一个方法调用在运行时可以根据对象的实际类型表现出不同的行为。这种机制的核心在于，方法的调用并不是在编译时确定的，而是在运行时根据对象的实际类型动态绑定到相应的方法实现上。这种动态绑定的特性使得多态成为可能，它极大地增强了代码的灵活性和可扩展性。
多态的实现依赖于继承和方法重写。继承为子类提供了父类的属性和方法，而方法重写则允许子类根据自己的需求重新定义这些方法。通过这种方式，子类可以在不改变父类接口的情况下，扩展或修改父类的行为。多态使得代码更加通用和灵活，因为父类的引用可以指向任何子类的对象，而调用的方法则会根据对象的实际类型动态确定。
多态不仅提高了代码的可扩展性，还使得代码更加简洁和易于维护。开发者可以通过父类的接口编写通用的代码，而具体的实现则由子类提供。这种设计模式使得代码更加模块化，也更容易适应未来的变化。例如，如果需要添加一个新的动物类型，只需要创建一个新的子类并重写相应的方法，而无需修改现有的代码逻辑。
下面的代码演示了如何使用多态
package oop.demo02;
public class Person {
public void run(){
System.out.println("run");
}
}
package oop.demo02;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}package oop.demo02;
public class Application {
public static void main(String[] args) {
//Student 子类型，能调用的方法都是自己的或者然承父类的!
Student s1 = new Student();
//Person 父类型，可以指向了类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
s2.run(); // 子类重写了父类的方法，执行子类的方法
s1.run();
//s2.eat(); 想调用子类的方法，需要强转，再执行
((Student) s2).eat();
s1.eat();
}
}son
son
eat
eat-
instanceof和类型转换
instanceof 是 Java 中的一个运算符，用于判断一个对象是否是指定类的实例，或者是否是其子类的实例。它在运行时检查对象的实际类型，并返回一个布尔值（true 或 false），表示对象是否属于指定的类或其子类。
package oop.demo02;
public class Application {
public static void main(String[] args) {
//Object > Person > Student
//Object > Person > Teacher
//Object > String
//System.out.println(X instanceof Y); // 低的能转高，因此编译可以通过；
Object object = new Student();
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
System.out.println(object instanceof String); //false
System.out.println("====================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //false
//System.out.println(person instanceof String); //编译报错！
System.out.println("====================");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //编译报错！
//System.out.println(student instanceof String); //编译报错！
}
}
类型转换
package com.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
public static void main(String[] args) {
//类型之间的转化：父 子
//高 低
Person obj = new Student();
//student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
Student student = (Student) obj;
// student.go();
((Student) obj).go();
//子类转换为父类，可能丢失自己的本来的一些方法！
Student student = new Student();
student.go();
Person person = student;
}
-
static关键字详解
package oop.demo07;
//static
public class Student {
private static int age; //静态的变量 多线程
private double score; //非静态的变量
public static void main(String[] args) {
Student s1 = new Student();
// 静态属性可以直接用；类名.的方式调用，而非静态不行
System.out.println(Student.age);
//System.out.println(Student.score);
System.out.println(s1.age);
System.out.println(s1.score);
}
}
package oop.demo07;
//static
public class Student {
private static int age; //静态的变量 多线程
private double score; //非静态的变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
// 静态方法可以直接调用，而非静态必须new一个对象再调用
//run();
Student.go();
go();
}
}
静态代码块
package oop.demo07;
public class Person {
{ // 2
//代码块（匿名代码块），对象创建就自动运行
System.out.println("匿名代码块");
}
static { // 1
//静态代码块，和类一起加载，只执行一次~
System.out.println("静态代码块");
}
public Person() { // 3
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("====================");
Person person2 = new Person();
}
}
静态代码块
匿名代码块
构造方法
====================
匿名代码块
构造方法静态导入包
package oop.demo07;
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random()); // 不需要Math.random()
System.out.println(PI);
}
}
-
final之后的类不能被其他类继承
-
抽象类
抽象类是面向对象编程中一个非常重要的概念，它是一种特殊的类，不能被实例化，但可以作为其他类的父类。抽象类的主要作用是为一组相关类提供一个通用的模板和规范，定义这些类所共有的方法和属性，同时允许子类根据具体需求实现或扩展这些方法。抽象类的核心在于它提供了一个抽象的框架，而具体的实现细节则由子类来完成。
抽象类可以包含抽象方法和具体方法。抽象方法是没有具体实现的方法，只有方法签名，没有方法体，子类必须提供这些抽象方法的具体实现。具体方法则是已经实现了的方法，子类可以直接继承这些方法，也可以选择覆盖它们。这种设计使得抽象类能够定义一个通用的接口，而具体的实现则由子类来完成，从而实现了代码的复用和灵活性。
- abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
- 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
- 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
- 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
抽象类存在的意义： 抽象出来，提高开发效率
package oop.demo08;
//abstract 抽象类：类 extends 单继承~ （接口可以多继承）
public abstract class Action {
//abstract 抽象方法，只有方法名字，没有方法的实现！由子类负责实现
public abstract void doSomething();
}
package oop.demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非子类也是抽象的（abstract）~
public class A extends Action {
@Override
public void doSomething() {
}
}
-
接口的定义与实现
接口是Java中用于定义规范的一种特殊类型，它是一种完全抽象的类，用于声明一组方法和常量，但不提供具体实现。接口的主要作用是定义一个通用的契约，使得不同的类可以实现这些契约，从而实现多态和代码的解耦。接口中的方法默认是public和abstract的，而接口中的变量默认是public、static和final的，即它们是常量。
接口的实现类必须实现接口中声明的所有方法，这确保了实现类遵循接口定义的契约。通过接口，可以定义一组行为规范，而具体的实现细节则由实现类来完成。这种方式使得接口成为一种强大的工具，用于实现松耦合的设计，提高代码的可维护性和可扩展性。
接口的设计体现了面向对象编程中的“面向接口编程”原则，即通过接口定义行为规范，而不是依赖于具体的实现类。这种方式使得代码更加灵活，因为调用者只需要关注接口，而不需要关心具体的实现细节。实现类可以在不修改接口的情况下，随时替换或扩展，从而实现高度的解耦和可扩展性。
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有!
- 接口:只有规范!自己无法写方法专业的约束！约束和实现分离：面向接口编程
接口是面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class,声明接口的关键字是interface
-
作用:
1. 约束
2. 定义一些方法，让不同的人实现~ 10 ---> 1
3. public abstract
4. public static final
5. 接口不能被实例化~，接口中没有构造方法~
6. implements可以实现多个接口
7. 必须要重写接口中的方法~
package oop.demo09;
//interface 定义的关键字 , 接口都需要有实现类
public interface UserService {
//常量 public static final
int AGE = 99;
//接口中的所有定义的方法其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package oop.demo09;
public interface TimeService {
void timer();
}
package oop.demo09;
//可以实现接口 implements 接口 父实现了接口的类，就需要重写接口中的方法~
//多继承~利用接口实现多继承~
public class UserServiceImpl implements UserService,TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
-
N种内部类
内部类是Java中一种特殊的类，它定义在另一个类的内部。内部类与外部类之间存在一种紧密的关联关系，这种关系使得内部类可以访问外部类的所有成员，包括私有成员。内部类的存在为Java语言提供了更灵活的封装和代码组织方式，同时也为实现复杂的逻辑和设计模式提供了便利。
内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1.成员内部类
成员内部类是定义在外部类内部的普通类，它作为外部类的一个成员存在。成员内部类可以访问外部类的所有成员，包括私有成员。外部类也可以访问成员内部类的成员，但需要通过内部类的实例来访问。
成员内部类的实例与外部类的实例相互独立，但内部类的实例可以持有外部类实例的引用。
package oop.demo10;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
// 内部类可以获得外部类的私有属性~
public void getID(){
System.out.println(id);
}
}
}public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过这个外部类来实例化内部类~
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
2.静态内部类
局部内部类是定义在方法内部的类，它的作用域仅限于定义它的方法。局部内部类通常用于实现特定方法的逻辑，它不能有访问修饰符，但可以访问方法的局部变量（前提是这些变量是final或实际final的）。
package oop.demo10;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public static class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
// 内部类可以获得外部类的私有属性~
public void getID(){
System.out.println(id);
}
}
}3.局部内部类
匿名内部类是一种没有类名的内部类，通常用于实现接口或继承类时，仅需要一个实例的场景。匿名内部类的语法是在 new 表达式中直接定义类的实现。它通常用于实现监听器接口或简化代码。
package oop.demo10;
public class Outer {
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
public static void main(String[] args) {
}
}
4.匿名内部类
静态内部类是定义在外部类内部的静态类。它与成员内部类的主要区别在于，静态内部类不能访问外部类的实例成员，但可以访问静态成员。静态内部类的实例与外部类的实例无关，可以通过外部类直接访问。
package com.oop.demo10;
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中~
new Apple().eat();
UserService userService = new UserService() {
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}-
🚀 知识的力量在于分享！ 🚀
如果你从我的分享中学到了新知识，或者觉得这些内容对你有帮助，请不吝点赞、关注和收藏！这样不仅能让我更有动力，还能帮助更多人看到这些内容。
👍 点赞：让我知道你收获了！
👀 关注：获取更多干货！
⭐️ 收藏：方便随时复习！
感谢您的支持，我们一起进步！