Java面向对象编程（基础）Java面向对象编程（OOP）

101 阅读 0 评论 67 点赞

我是靠谱客的博主灵巧冬瓜，这篇文章主要介绍Java面向对象编程（基础）Java面向对象编程（OOP），现在分享给大家，希望可以做个参考。

Java面向对象编程（OOP）

1.初识面向对象

1.1 面向过程

步骤清晰简单，第一步做什么，第二步做什么…
面对过程适合处理一下简单问题

1.2 面向对象思维

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些类，然后对这些类进行单独思考，最后，才对某个分类下的细节进行面向过程思考
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

1.3 什么是面向对象

本质：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特性：封装，继承，多态

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程思路去处理

比如，造房子需要建筑师，粉刷匠，搬运工（对象），这些对象各自做的事情要按照一定方法（过程）

2.方法回顾和加深

2.1 方法的定义

修饰符（public，static，final…）
返回类型
break（结束循环，跳出switch） and return（结束方法）的区别
方法名：驼峰命名
参数列表（参数类型参数名）
异常抛出

复制代码

1
2
3
4
5
public void readFile(String file) thorws IOException{
}
//数组下标越界
Arrayindexoutofbounds

2.2 方法的调用:(包括递归)

静态方法（static）

复制代码

1
2
3
Student.say();
Arrays.fill(nums,0);

非静态方法

复制代码

1
2
3
4
5
6
//实例化一个类 new
new Student().say();
一般是这样写
Student s = new Student();
s.say();

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
public class demo1{
//和类一起加载的
public static void a(){
b();//X，不能调用还没有存在的函数
//正确调用函数b（）,应该先实例化对象
demo1 d = new demo1();
d.b();
}
//类实例化之后才存在
public void b(){
}
}

形参和实参

复制代码

1
2
3
4
5
6
7
8
9
10
public class demo3{
public static void main(String[] args){
//实际参数和形式参数的类型要对应
int add = demo3.add(1,2)//实参
}
public static int add(int a,int b){//形参
return a+b;
}
}

值传递和引用传递

Java都是值传递

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
//值传递
public class demo4{
public static void main(String[] args){
int a=1;
System.out.println(a);//a=1
demo4.change(a);
System.out.println(a);//a=1
}
public static void change(int a){
a=10;
}
}

引用传递：传递一个对象，本质还是值传递

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//引用传递：对象，本质还是值传递
public class demo5{
public static void main(String[] args){
Person perosn = new Person();
System.out.println(person.name);//null
change(person);
System.out.println(person);//lhp
}
public void change(Person person){
//person是一个对象，指向---->Person类，这是一个具体的人，可以改变属性
peoson.name="lhp";
}
}
//一个Java文件里面只允许有一个public类，但是可以有多个类
//定义一个Person类，有一个属性：name
class Person{
String name;
}

this关键字：代表当前这个类，如果写了static，则不能使用this

3.对象的创建分析

使用new创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创造好的对象进行默认初始化，以及对类中构造器调用
类中的构造器也称构造方法，是进行创建对象的时候必须要调用的，并且构造有两个特点：

必须和类的名字相同
必须没有返回类型，也不能写void

3.1构造器

一个类即使什么都不写，它也会存在一个方法（无参构造）
无参构造可以初始化一些信息

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.operator.test02;
public class Person {
String name;
//使用new关键字，必须要有构造器
//new关键字的本质是调用构造器
//无参构造(显示定义)
public Person(){
this.name="lhp";
}
//有参构造
//一旦有了有参构造，无参构造就必须显示定义！！！
//如果定义了有参构造，再去调用无参构造，就必须要显示定义无参构造！！
public Person(String name){
this.name=name;
}
}
//Alt + insert
----> 点击constructor，自动生成构造器

复制代码

1
2
3
4
5
6
7
8
9
10
package com.operator.test02;
//一个项目只允许有一个main方法，用于测试
public class Application {
public static void main(String[] args) {
//如果定义了有参构造，再去调用无参构造，就必须要显示定义无参构造！！
Person perosn1=new Person();
Person person2=new Person("lhp");
}
}

构造器：1.构造器和类名相同。2.并且没有返回值。

作用：1.new本质在调用构造方法。1.初始化对象。

注意：1.定义有参构造之后，如果想要使用无参构造，就必须显示定义一个无参构造！！！

快捷键：**Alt + Insert **，点击constructor

类里面只有属性和方法

复制代码

1
2
3
4
5
6
7
8
public class Student{
String name;
int age;
public void study(){
System.out.println(this.name+"student");
}
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//一个项目只允许有一个main方法，用于测试
public class Application {
public static void main(String[] args) {
student lhp = new student();
student lrx = new student();
lhp.name="lhp";
lrx.name="lrx";
lhp.age=20;
lrx.age=23;
System.out.println(lhp.name+":"+lhp.age);
System.out.println(lrx.name+":"+lrx.age);
}
}

3.2创建对象内存分析

详见狂神说Java

&面向对象小总结

类与对象：类是一个模板：抽象。对象是一个具体实例
方法：定义，调用
对应的引用：

引用类型：基本类型（8个）

对象是通过引用来操作的：栈—>堆

属性：字段Field，成员变量

默认初始化：

数字：0 ， 0.0

char：u0000

boolean：false

引用： null

修饰符属性类型属性名 = 属性值！

对象的创建和使用

必须使用new关键字创建对象，构造器 Person person= new Person()

对象的属性 person.name

对象的方法 person.sleep()

类：

静态属性：属性

动态方法：方法

4.面向对象三大特性

4.1 封装

程序设计追求“高内聚，低耦合”。高内聚：类的内部数据操作细节自己完成。低耦合：仅暴露少量的方法供外部使用
封装（数据的隐藏）

通常，应该禁止直接访问一个对象中的实际表示，而应该通过操作接口来访问，这称为信息隐藏

记住这句话：属性私有，get / set（对外的接口）

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.operator.test02;
public class Person {
//属性私有
private String name;
private int age;
//set和get是私有类属性对外的接口
//在类往外面获得私有属性的信息
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;
}
//快捷键Alt + insert
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
package com.operator.test02;
//一个项目只允许有一个main方法，用于测试
public class Application {
public static void main(String[] args) {
Person person = new Person();
person.setAge(20);
person.setName("lhp");
System.out.println(person.getAge());
System.out.println(person.getName());
}
}

意义：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护增加了

4.2 继承

本质是堆某一批类的抽象，从而实现堆现实世界更好的建模
extends的意思是“扩展”，子类是父类的扩展
Java中类只有单继承，没有多继承！（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）
私有的东西无法被继承

复制代码

1
2
3
4
public class student extends Person{}//Person的单继承
public class teacher extends Person{}//Person的单继承
public class s1 extends student{}//X Person的多继承不可以用

继承是类和类之间的一种关系，除此之外，类和类还有依赖，组合，聚合等的关系
继承关系的两个类，一个为子类（派生类），一个为父类(基类）。子类继承父类使用关键字extends来表示
子类和父类从意义上讲应该有“is a ”的关系
object类
super
方法重写

注意：

子类可以继承父类的所有public方法
Ctrl + H可以看继承的关系树
在Java中，所有的类都默认直接或者间接继承Object类

4.2.1 super（对比this）

复制代码

1
2
3
4
5
6
7
8
9
10
11
//父类
public class Person {
private String name;
public Person() {
this.name = "lrx";
}
public String getName() {
return name;
}
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
//子类
public class student extends Person{
String name;
public student() {
this.name="lhp";
}
public void test(){
System.out.println(this.name);// lhp
System.out.println(super.getName()); //lrx
}
}

同时，对于创建一个子类，会优先调用父类的构造器，隐藏代码，不然会报错

必须先有爸爸，才能有儿子

复制代码

1
2
3
4
5
6
7
//在main中创建一个student对象
student stu = new student();
//在student中的无参构造有隐藏代码
public student(){
super();//隐藏代码，必须优先执行super父类的构造函数，必须在子类构造器的第一行
}

super注意点：

super是调用父类的构造方法，必须放在子类构造方法的第一个（父类无无参构造默认不显示）
super必须出现在子类的方法或者构造方法中！
super和this不能同时调用构造方法

super和this的对比：

代表的对象不同:

this：代表本身调用者这个对象

super：代表父类对象的引用

使用前提：

this：没有继承也可以使用

super：只有在继承条件下才可以使用

调用构造方法的区别：

this():调用本类的无参构造

super():调用父类的无参构造

4.2.2 方法重写

4.2.2.1静态方法下的重写

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//父类
public class A {
public static void test(){
System.out.println("A->test");
}
}
//子类
public class B extends A {
public static void test(){
//Override:重写的意思
//快捷键 Alt + insert
@Override //注解：有功能的注解
System.out.println("B->test");
}
}
//main
//重写都是方法的重写，和属性无关
public static void main(String[] args) {
//静态方法：方法的调用只和左边，即定义的数据类型有关
B b = new B();//子类
b.test();//B->test
//父类的引用指向了子类
A a = new B();//父类
a.test();//A->test
}

4.2.2.2 非静态方法下的重写

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//父类
public class A {
public void test(){
System.out.println("A->test");
}
}
//子类
public class B extends A {
public void test(){
//Override:重写的意思
//快捷键 Alt + insert
@Override //注解：有功能的注解
System.out.println("B->test");
}
}
//main
//重写都是方法的重写，和属性无关
public static void main(String[] args) {
//非静态方法才有重写
B b = new B();//子类
b.test();//B->test
//父类的引用指向了子类
A a = new B();//父类
a.test();//B->test!!!(区别上面的静态方法)
//非静态方法只打印子类的方法
}

注意：

静态的方法和非静态的方法区别很大，

静态方法（static）：方法调用只和左边，即定义的数据类型有关
非静态方法：非静态方法才有重写

4.2.2.3 总结

重写：需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但不能缩小：public > protected > default > private

父类是private的方法，子类可以是重写为public，返之则不行

抛出的异常：异常的范围，可以缩小，但是不能扩大。（就好像你爸爸欠了100万，儿子继承父亲，就应该欠的更少）

Exception(大)-------------->ClassNotFoundException(小)

重写，子类的方法和父类必须一致；方法体不同

为什么需要重写？

父类的功能，子类不一定满足，不一定需要！

重写快捷键：Alt + Insert

4.3 多态

动态编译：使类型的可扩展性增强（编译的时候才确定对象）
同一个方法可以根据发送对象的不同而采取多种不同的行为方式
一个的实际类型使确定的，但可以指向对象的引用的类型有很多（父类引用子类，有关系的类引用）
注意：多态是方法的多态，属性没有多态性
instanceof（类型转换->引用类型之间的转换）

4.3.1 多态存在的条件：

有继承关系
子类重写父类方法（非静态方法）
父类引用指向子类对象

注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系。否则有类型转换异常！（ClassCastException!）
多态存在的条件：要有继承关系，方法需要重写，父类引用指向子类对象(Father f1 = new Son;)
有些方法不能重写：static 方法：属于类，它不属于实例

final 常量

private 方法

4.3.2 instanceof和类型转换

instanceof判断两个类是否有关系

复制代码

public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Student
/*
System.out.println(X instanceof Y);
instanceof作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型
如果编译通过，说明存在父子关系，如果编译不通过，则不存在父子关系
左边是对象X，右边是类Y；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
*/
//要是没有关系，instanceof就会报错
Object object = new Student();//这里的object是Student类，但指向Object
System.out.println(object instanceof Student);//true子类创建的对象
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Teacher);//false
//如果Object object = new Teacher();则object instanceof Teacher为true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false
System.out.println("--------------------------------");
Person perosn = new Student();
System.out.println(perosn instanceof Student);//true子类创建的对象
System.out.println(perosn instanceof Person);//true类创建的对象
System.out.println(perosn instanceof Object);//true父类创建的对象
System.out.println(perosn instanceof Teacher);//false
// System.out.println(perosn 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);//编译报错
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Student
/*
System.out.println(X instanceof Y);
instanceof作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型
如果编译通过，说明存在父子关系，如果编译不通过，则不存在父子关系
左边是对象X，右边是类Y；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
*/
//要是没有关系，instanceof就会报错
Object object = new Student();//这里的object是Student类，但指向Object
System.out.println(object instanceof Student);//true子类创建的对象
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Teacher);//false
//如果Object object = new Teacher();则object instanceof Teacher为true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false
System.out.println("--------------------------------");
Person perosn = new Student();
System.out.println(perosn instanceof Student);//true子类创建的对象
System.out.println(perosn instanceof Person);//true类创建的对象
System.out.println(perosn instanceof Object);//true父类创建的对象
System.out.println(perosn instanceof Teacher);//false
// System.out.println(perosn 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);//编译报错
}

null用instanceof跟任何类型比较时都是false

复制代码

1
2
if(null instanceof String)//false

左边的对象实例不能是基础数据类型：

复制代码

1
2
3
double b;
if(b instanceof Double)//编译报错

左边的对象实例和右边的类不在同一个继承树上

复制代码

1
2
3
String name;
if(name instanceof Double)//编译报错

类型转换

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void main(String[] args){
//类型之间的转化： 高--------低
//高
低
Person obj = new Student();
//将obj这个对象转换位Student类型，我们就可以用Student类型的go方法了！
Student
student = (Student) obj;
//或者
((Student) obj).go();
//子类转换为父类，可能丢失自己本来的一些方法
Student s1 = new Student();
s1.go();
Person person = s1;
//person.go()//X ， 无法调用
}
/*
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型，不用强制转换；
3.父类转换成子类，需要强制转换；
4.方便方法的调用，减少重复代码，简洁
*/

5 static详解

静态变量和静态方法:

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.operator.test02;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
public class Student extends Person{
private static int age;//静态变量
private double score;//非静态变量
public static void go(){//静态方法
//run();静态方法不可以直接调用非静态方法，需要实例化对象才可以
Student s = new Student();
s.run();
}
public static void walk(){
go();//静态方法可以调用静态方法
}
public void run(){//非静态方法
go();//非静态方法可以调用静态方法
}
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);//非静态属性必须通过实例化再调用
//------------------------------------------
Student.go();//静态方法可以之间通过类名调用
//Student.run();非静态方法不可以直接通过类名调用
s1.go();
s1.run();//非静态方法必须通过实例化对象再调用
}
}

静态代码块：

静态代码块只执行一次

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Person {
//第二个执行,一般来赋初始值
{
//代码块（匿名方法）
System.out.println("匿名方法块");
}
//第一个执行,但是只执行一次
static{
//静态代码块（匿名静态方法）
System.out.println("静态方法块");
}
//第三个执行
public Person(){
System.out.println("构造器");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("==================");
Person person2= new Person();
}
/*
输出：
静态方法块
匿名方法块
构造器
==================
匿名方法块
构造器
*/
}

静态导入包（很少这么用，只做了解）

复制代码

1
2
3
4
5
6
7
import static java.lang.Math.randon;//不加static会报错
public class Test{
public static void main(String[] args){
System.out.println(random());
}
}

6. final

如果是由final，则表示是常量，并且final修饰的类不能被继承，断子绝孙

复制代码

1
2
3
4
5
public final class Person{
}
public class student extends Person{//编译报错，person是final修饰的，不可以继承
}

7.抽象类和接口

7.1 抽象类

abstract修饰符可以用来修饰方法，也可以来修饰类，分别表示抽象方法和抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class action {
//方法的约束~有人帮我们实现，适合宏观写框架
//abstract,抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
}
//抽象类的所有方法，继承它的子类，必须实现抽象类的所有方法，除非这个子类也是抽象类
public class A extends action {
@Override
public void doSomething() {
}
}

特点：

抽象类不能new，只能靠子类去实现它，是一个约束！
抽象类里面可以写普通方法
抽象方法必须在抽象类中
抽象的抽象：约束

思考：

抽象类存在构造器吗？存在构造器

抽象类存在的意义？将共性抽象出来，节省代码量，提高开发效率

（就比如游戏里面创建一个角色，角色刚开始都一样，这是共性，后来可以重写一些方法，使角色升级，这是个性）

7.2 接口

类（extends）都是单继承，但是接口可以多继承！！！

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范（抽象方法）！自己无法写方法，它是专业的约束，约束和实现分离，很多时候都是面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO（面向对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具有抽象能力的语言，就是因为设计模式所研究的，实际上是如何合理地去抽象。

声明类的关键字是class，声明接口的关键字是interface

复制代码

1
2
3
4
5
6
7
8
9
10
11
//interface 定义的关键字
//接口都需要有一个实现类，实现类一般都是impl结尾
public interface UserService {
//接口中所有方法都是抽象的，默认是public abstract
//定义增删改查
void add(String name);//默认public abstrac
void delete(String name);
void update(String name);
void quary(String name);
}

复制代码

1
2
3
4
public interface TimeService {
void time();
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//架构师的抽象思维是否优秀
//抽象类 ：extends 单继承
//类 可以实现接口， 用implements（实现）+接口， 可以是多继承
//实现了接口的类
//通过接口可以实现多继承
public class UserServiceImpl implements UserService,TimeService{
//在接口里面定义常量，默认public static final,但是一般没有人在接口里面定义常量
//int age = 99;
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void quary(String name) {
}
@Override
public void time() {
}
}

接口的作用:

约束
定义一些方法，让不同的人实现
接口里面的方法都是public abstract
接口常量都是public static fianl
接口不能实例化，因为接口不是类，没有构造方法
implements可以实现多个接口
必须重写接口里面的方法

8.内部类以及OOP实战

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类就是外部类。

内部类的分类：

1.成员内部类

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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("outer id:"+id);
}
}
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Application03 {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
}
}
/*
输出：
这是内部类的方法
outer id:10
*/

2.静态内部类

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Outer {
private int id=10;//默认值
public void out(){
System.out.println("这是外部类的方法");
}
//静态内部类先初始化，就不能直接访问到id了，要是想要访问id，旧的将id也变成static
//静态内部类无法访问非静态属性，因为静态时先执行的，非静态还没来得及执行
public static class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
}
}

复制代码

1
2
3
4
5
6
public class Application03 {
public static void main(String[] args) {
Outer outer = new Outer();
}
}

3.局部内部类

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
//写在方法里面（局部内部类）
public class Outer {
//定义在方法里面的类
//局部内部类
public void method(){
class inner{
public void in(){
}
}
}
}

4.匿名内部类

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.operator.test03;
import com.operator.test02.UserService;
public class Application03 {
public static void main(String[] args) {
//没有名字初始化类，不用讲实例保存到变量中
//匿名内部类
new Apple().eat();
//内部类高阶玩法,实现接口
//匿名内部类/匿名接口
new UserService03(){
@Override
public void eat() {
}
};
}
}
//同一个文件下只能有一个public类，但是同一个类里面，可以有多个public内部类
class Apple{//也算内部类
public void eat(){
System.out.println("eat");
}
}
interface UserService03{
void eat();
}

最后

以上就是灵巧冬瓜最近收集整理的关于Java面向对象编程（基础）Java面向对象编程（OOP）的全部内容，更多相关Java面向对象编程（基础）Java面向对象编程（OOP）内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：java
浏览次数：101 次浏览
发布日期：2024-01-12 07:00:49
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_ogf1_14__23__26_w.html

Java面向对象编程（基础）Java面向对象编程（OOP）

Java面向对象编程（OOP）

1.初识面向对象

1.1 面向过程

1.2 面向对象思维

1.3 什么是面向对象

2.方法回顾和加深

2.1 方法的定义

2.2 方法的调用:(包括递归)

3.对象的创建分析

3.1构造器

3.2创建对象内存分析

&面向对象小总结

4.面向对象三大特性

4.1 封装

4.2 继承

4.2.1 super（对比this）

4.2.2 方法重写

4.2.2.1静态方法下的重写

4.2.2.2 非静态方法下的重写

4.2.2.3 总结

4.3 多态

4.3.1 多态存在的条件：

4.3.2 instanceof和类型转换

5 static详解

6. final

7.抽象类和接口

7.1 抽象类

7.2 接口

8.内部类以及OOP实战

最后

评论列表共有 0 条评论

发表评论取消回复

Java面向对象编程（基础）Java面向对象编程（OOP）

Java面向对象编程（OOP）

1.初识面向对象

1.1 面向过程

1.2 面向对象思维

1.3 什么是面向对象

2.方法回顾和加深

2.1 方法的定义

2.2 方法的调用:(包括递归)

3.对象的创建分析

3.1构造器

3.2创建对象内存分析

&面向对象小总结

4.面向对象三大特性

4.1 封装

4.2 继承

4.2.1 super（对比this）

4.2.2 方法重写

4.2.2.1静态方法下的重写

4.2.2.2 非静态方法下的重写

4.2.2.3 总结

4.3 多态

4.3.1 多态存在的条件：

4.3.2 instanceof和类型转换

5 static详解

6. final

7.抽象类和接口

7.1 抽象类

7.2 接口

8.内部类以及OOP实战

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复