Java基础学习-面向对象总复习（理解）

原创已于 2025-04-14 08:55:33 修改 · 127 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #后端

于 2023-11-18 20:10:53 首次发布

技术学习同时被 2 个专栏收录

38 篇文章

订阅专栏

Java基础学习

7 篇文章

订阅专栏

类：是抽象的，没有实体。同时也是一个集合，是属性和方法（行为）的集合。

属性：是类所具有的可以在类中的所有的地方都调用的东西。

1.1 属性的声明：权限修饰符所属的类型（可以是自定义的类）变量名

比如：public int number；

1. 权限修饰符种类：

Public ：在所有类下都能使用，当要使用的方法在不同

的包中时，需要导入当下的包，兵器导入当

的类。

缺省：在包中的其他类使用，不能给子类使用。

Protected ：在包中的所有类和子类使用都能访问，能

访问。

Private ：只能在本类中使用，出了类，就不能调用。

⭐ 权限修饰符的作用：权限修饰符体现了Java 语言的封装性。

1. 所属的类型：可以是已有的类：int char String …

也可以是自己已经声明过的类。

方法：是在类的内部，具体实现多种功能的方法。

2.1方法同样也能用权限修饰符进行修饰。

2.2 方法的声明：权限修饰符返回值类型方法名（参数列表）

2.3 返回子类型同样可以是自定义的类，参数列表同样可以是自定义的类型。

2.4 方法也有分类：

静态方法：

声明：权限修饰符 static 返回值类型方法名（参数列表）
用法：静态方法不需要对象就能通过类名调用，类名.方法名（参数列表）

非静态方法：

- 权限修饰符返回值类型方法名（参数列表）
- 必须使用对象来调用方法。

抽象方法：

声明：权限修饰符 abstract 返回值类型方法名（参数列表）；
抽象方法只能在抽象类中声明
抽象方法没有方法体，只能被子类继承所覆盖。
抽象方法必须生命在抽象类中，或声明在接口中。

2.5 方法的重载：在声明方法时，如果需要声明方法名相同的方法时，两个方

法名相同的，但是参数列表不相同，则构成方法的重载。

方法的重写：就是继承之后，子类覆盖父类的方法

2.6 static 的使用：

声明：权限修饰符 static 返回值类型方法名（参数列表）
作用：被static 修饰的方法，称为静态方法，不需要创建对象用

类.方法（）调用方法

2.7 this 的使用：在声明方法时，方法的参数列表的参数名可以与属性同名

做到见名知意。

形式：this.属性名 = 形参名

意义：this 表示调用此方法的对象的…

对象：是具体的，是类的实现，可以用对象去调用类里面的东西。

1）对象是用来实现类的，可以用对象来调用类里面的方法和属性。

创建对象：

类名对象名 = new 类名（）；
类名变量名；

变量名 = new 类名（）；

调用方法：
- 对象名.方法名（）；
- New 类名.方法（）；

注意：new 出来的就是对象，可以有名字，也可以没有名字。（匿名对象）

即：person p = new person（）；

可以理解为： p == new person（）

继承：

3.1 关键字：extends 延展、延伸

3.2 用法：class 类名 extends 类名

3.3 多层继承：一个父类拥有多个子类。

多重继承：一个子类继承多个父类，这在Java中是不被允许的。

3.4 继承的含义：就是继承父类的所有属性和方法（包括私有的）

同样的，子类在继承了父类之后，就能通过创建子类的对象，来

调用父类的对象。

3.5 子类不仅可以继承父类的方法，还可以继续写自己独有的方法。同样当子类的方

法也可以声明与父类的方法同名，同参数的方法，从而覆盖父类的方法，调用子

类重写的方法。

3.6 super 的使用：

使用格式：super。方法（）；
作用：虽然在子类中重写了父类的方法，但是还想要调用父类的方法时

可以用，super 可以表示为：父类的。

3.7 final ：

① 用final 修饰的类：不能被继承，是最终类。

用final 修饰的方法不能被重写
Final static 修饰的属性为全局常量，只能赋值一次，就像数学中的PI

一样，不能被赋值。

多态：

没有继承就没有多态!

4.1 当一个类（man）继承于另一个类（person）时，声明父类类型。造的是子类的

对象

多态性的体现：

Person p1 = new man（）；

多态性的应用：虚方法调用

编译看左边，执行看右边

当用p1调用方法时，用的是new 的对象（man）的重写的方法。

1. 多态性使用的前提：

- 要有继承关系
- 要有重写的方法

1. 多态的使用：

仅适用于方法，不适用于属性。

1. 多态的具体使用：

AnimalTest test = new AnimalTest();

                  test.adopt(new dog());

 

                  public void adopt (Animal animal)  //Animal animal = new dog()

                  {

                                  

                 }

⭐注意：这里只能调用Anlimal 里面的方法，不能调用dog 里面的方法

但是，调用的Animal 里面的方法是dog 里面重写过的，

1. 多态的主要应用场景是形参处的多态
2. 转型符（）：
用于类型的强制转换。
分为向下转型，向上转型。
比如：person p1 = new woman（）；

man m2 = （man）p1； //将p1强转为 man类型。

可能出现类型转换异常。
1. instanceof ：判断当前对象的类型是否与后面的类型一样。

格式：对象 instanceof String //判断对象是不是 String

返回值类型：是布尔型（true / false ）

作用：非要使用对象中特有的方法。

接口

5.1 关键字：interface

主要格式：interface （接口名）

5.2 在接口中的声明：

① 属性：必须使用 public static final 修饰（全局常量） //可以说省略

② 方法：jdk8之前：声明抽象方法，修饰为：public abstract //可以省略

jdk8：可以声明静态方法

jdk9：可以声明名私有方法

5.3 在接口中不能声明：构造器、代码块。

5.4 接口的实现：

关键字：implements
格式：class 类名 implements 接口名
可以实现多个接口：

class 类名 implement 接口名，接口名…

在类中实现的接口后，必须将所有实现的接口中的抽象方法重写一遍

后者，该类声明为抽象类。

继承在实现的前面。

5.5 接口与接口的关系：

① 接口与接口也可以有继承关系，并且可以多继承

比如：interface A extends B，C，D…

5.6 接口的多态性：接口名变量名 = new 实现类的对象（实现类的名字）

理解：编译时，编译器认为的是接口中的抽象方法，但是执行时，

执行的是实现类中重写的接口的抽象方法

内部类
1. 内部类的理解：

① 内部类也是类，可以有属性、有方法、构造器、内部类。

② 内部类也可以继承父类，实现多个接口。

③ 同样也可以使用abstract 进行修饰

6.2 从成员变量看内部类：

① 内部类因为是成员变量，因此可以使用private 进行修饰。

② 内部类还可以用static 进行修饰。

6.3 内部类的使用：

1）静态内部类的使用：

① 由于静态内部类是随着类的加载而加载，因此只需要声明

内部类的使用就好了。

eg：Animal.Dog d = new Animal.Dog();

d.eat();

2）非静态内部类的使用：

① 由于非静态内部类不是随着类的加载而加载，因此不一样。

比如：Animal p1 = new Animal();

Animal.cat c = p1.new cat();

c.eat();

6.4 如何在非静态内部类中调用外部类的结构：

1) 内部类调用外部类的属性：运用：外部类名.this.外部类的属性名

2）内部类调用外部类的方法

① 形式：外部类名.this.外部类的方法（）

（与属性的结果相同）

3）局部内部类：

① 如果一个内部类定义在方法、构造器、代码块里，就称为局部内部类。

② 局部内部类可以同名。


class Animal   //外部类

String name = "动物";

             int age = 1;

class cat    //非静态内部类

                String name = "小花猫";

System.out.println("age = " + age);  //调用的是外部类的属性 age省略了Animal.this.                      

System.out.println("name = " + name);  //调用的是内部类的方法的形参的 name

System.out.println("name = " + this.name);  //调用的是内部类的属性 name

System.out.println("name = " + Animal.this.name);  //调用的是外部类的属性 name

4）局部类的应用：

public class lianxi

{

       public static void main(String[] args)

       {

              //Object类的子类的局部类的匿名对象

              new Object()

              {

                     public void test()

                     {

                            System.out.println("独酌");

                     }

              }.test();

       }

}

接口和内部类的总结（来自尚硅谷）

public class OtherClass

{

public static void main(String[]args)

{

//标准写法:实现接口

SubA a = new SubA();

a.method();





//举例 1：提供接口匿名实现类的对象

A a1 = new A()

{

public void method()

{

System.out.println("匿名实现类重写method()01");

}

};

a1.method();





//举例 2：提供接口匿名实现类的匿名对象

new A()

{

public void method()

{

System.out.println("匿名实现类重写method()02");

}

}.method();

   









         //标准写法:抽象类的

SubB s1 = new SubB();

s1.method1();





//举例 1：提供了继承于抽象类的匿名子类的对象

B b = new B()

{

public void method1()

{

System.out.println("继承于抽象类的子类调用的方法01");

}

};

b.method1();





//举例 2：

new B()

{

public void method1()

{

System.out.println("继承于抽象类的子类调用的方法02");

}

}.method1();









//标准写法：

C c = new C();

c.method2();



//举例 1：提供了一个继承于C的匿名子类的对象

C c1 = new C(){};

c1.method2();



//或者

C c2 = new C()

{

public void method2()

{

System.out.println("SubC");

}

};

c2.method2();



}



}



interface A

{

public void method();

}



class SubA implements A

{

@Override

public void method()

{

System.out.println("SubA");

}

}



abstract class B

{

public abstract void method1();

}



class SubB extends B

{

@Override

public void method1()

{

System.out.println("SubB");

}

}



class C

{

public void method2()

{

System.out.println("C");

}

}