Java之面向对象编程

最新推荐文章于 2024-06-25 02:12:30 发布

wy_43431863

最新推荐文章于 2024-06-25 02:12:30 发布

阅读量254

点赞数

分类专栏： Java基础文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_43431863/article/details/120772553

版权

Java基础专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本文概述了面向对象编程的核心概念，包括类与对象的关系、方法的定义与调用、对象创建与分析、三大特性（封装、继承、多态）及其应用。深入探讨了抽象类、接口、内部类和异常处理，提供了实际编程中的实战案例和技巧。

摘要由CSDN通过智能技术生成

1. 初识面向对象

面向过程思想：
步骤清晰简单，第一步做什么，第二步做什么…
面对过程适合处理一些较为简单的问题
面向对象的思想：
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去解决。

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

从认识论角度是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行的角度考虑是先有类后有对象。类是对象的模板

2. 方法回顾和加深

在这里插入图片描述
方法的定义

修饰符
返回类型
break：跳出switch，结束循环，return：结束方法返回一个结果
方法名：注意规范，见名知意
参数列表（参数类型、参数名）…
异常抛出

方法的调用：递归
1、静态方法调用
在这里插入图片描述

在这里插入图片描述

2、动态方法调用
在这里插入图片描述

3、类之间的调用

注意：一个静态方法的类无法调用一个动态方法的类，因为动态方法的类实例化后才存在。

在这里插入图片描述

4、值传递
在这里插入图片描述

注意：因为Java是值传递，所以出现下面情况

在这里插入图片描述
5、引用传递

6、this关键字

3. 对象的创建和分析

类与对象小结
1、类与对象
类是一个模板：抽象，对象是一个具体的实例
2、方法
定义、调用
3、对象的引用
引用类型&&基本类型（8）
基本类型：int、byte、char、short、long、float、double、boolean。引用类型：String、数组、对象
对象是通过引用来操作的：栈->堆
4、属性：字段Filed 成员变量
默认初始化：
数字：0 0.0
char:u0000
boolean:false
引用：null
修饰符属性类型属性名 =属性值！
5、对象的创建和使用
1）必须使用new关键字创建对象，
构造器Person wy=new Person();
2)对象的属性 wy.name
3)对象的方法wy.work();
6、类
静态的属性属性
动态的行为方法
封装继承多态

类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
  如动物、植物、手机、电脑
  Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
- 对象是抽象概念的具体实例
  张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
  能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下俩特点：

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

构造器务必掌握

一个项目应该只有一个main方法

类：抽象的、实例化的类实例化后返回一个自己的对象

在这里插入图片描述

构造器详解

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

-快捷生成alt+insert

构造器快捷键生成
alt+insert
在这里插入图片描述
无参构造器生成

有参构造器生成
一个参的：

两个参的：

构造器的作用

1）使用new关键字，本质是在调用构造器
2）是实例化初始值，一般做游戏的话会初始化一些值
注意点：
1. 一旦定义了有参构造，无参构造器也要显示定义，即使放那空着
2. this.一般是这个类的，而后面=的值是参数传进来的值

在这里插入图片描述

构造器解释

什么是构造器构造器通常也叫构造方法、构造函数，构造器在每个项目中几乎无处不在。当你new一个对象时，就会调用构造器。构造器格式如下：
[修饰符，比如public] 类名 (参数列表，可以没有参数){ //这里不能有return}

一个类即使什么都不写，他也会存在一个方法（在Java源文件里可以看出默认添加了方法）
当构造器里啥也不写时
有参构造器也叫重载–一旦定义了有参构造，无参就必须显示定义
1)
2)一旦定义了有参构造，无参构造器必须空着，否则当根据参数类型选择构造器的时候如果是没传参，则报错，因为无参的构造器被有参的构造器覆盖

package com.wang.gouzaoqi;

public class gzq {
    String name;
    int age;
    char gender;
    public void person1(){//声明方法
        System.out.println("");
    }
    //声明一个参数的构造器，通过参数传递进来给属性赋值
        public gzq(String name) {
            System.out.println("构造器1执行");
        //那个对象调用这个构造器，这个this就指向哪个对象
            this.name = name;
        }
    //两个参数的构造器
        public gzq(String name, int age) {

            this.name = name;
            this.age = age;
            //为了防止重复写，就简写
//            this(name);
//            this.age=age;
            System.out.println("构造器2执行");
        }
    //三个参的构造器
        public gzq(String name, int age, char gender) {
            //
            this.name = name;
            this.age = age;
            this.gender = gender;
            System.out.println("构造器3执行");
        }

        public static void main(String[] args) {
        //创建对象的过程其实是调用了构造器，并且给name等赋值(参数的传递），根据参数的个数来进行构造器的选择
            gzq person =new gzq("小王",20,'女');
            System.out.println(person.name);
            System.out.println(person.age);
            System.out.println(person.gender);
        }
}

执行结果
在这里插入图片描述

三个构造器中的是有重复代码时，可以通过调用上一个已经声明过对象的构造器，只能在构造器中使用这个方法

所以最后输出的时候，虽然是用的第三个构造器会输出第一个构造器打印的内容

在这里插入图片描述

package com.wang.gouzaoqi;

public class gzq {
    String name;
    int age;
    char gender;
    public void person1(){//声明方法
        System.out.println("");
    }
    //声明一个参数的构造器，通过参数传递进来给属性赋值
        public gzq(String name) {
            System.out.println("构造器1执行");
        //那个对象调用这个构造器，这个this就指向哪个对象
            this.name = name;
        }
    //两个参数的构造器
        public gzq(String name, int age) {

    //        this.name = name;
    //        this.age = age;
            //为了防止重复写，就简写
            this(name);//!!!必须放在第一行
            this.age=age;
            System.out.println("构造器2执行");
        }
    //三个参的构造器
        public gzq(String name, int age, char gender) {
            //
            this(name,age);
            this.gender = gender;
            System.out.println("构造器3执行");
        }

        public static void main(String[] args) {
        //创建对象的过程其实是调用了构造器，并且给name等赋值(参数的传递），根据参数的个数来进行构造器的选择
            gzq person =new gzq("小王",20,'女');
            System.out.println(person.name);
            System.out.println(person.age);
            System.out.println(person.gender);
        }
}

执行结果
在这里插入图片描述

构造器总结

在这里插入图片描述

创建对象内存分析

在这里插入图片描述

4.面向对象三大特性

封装详解

该露的露，该藏的藏

程序设计要求高内聚低耦合，高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

封装(数据的隐藏)-一般是属性会设置会私有，不能直接访问

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

属性私有get/set
当属性为私有变量时，外部类不能访问
解决办法–通过get、set方法(快捷键)

快捷键生成法：alt+insert
封装好处

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

继承(查看继承关系Ctrl+H)

如果是修饰符是final就不能被继承了，他就没有子类了

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”。子类是父类的扩展
JAVA中只有单继承，没有多继承
继承是类与类之间的一种关系，除此之外，类与类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系
object类
super
方法重写

student和teacher类继承person类，在person类定义say()方法，在application类中new student(),然后可以输出say()方法输出语句，因为student继承了person类，所以用于person类中定义的public方法。

特性

子类继承了父类，就会拥有父类的全部方法，前提是父类的属性和方法都要是共有的public,如果是private方法的话就要通过get、set方法来访问，
所有类都继承Object类
方法的优先级
- public
- protected
- default
- private(被这个词修饰的方法或属性就不能被继承了）

继承属性

在这里插入图片描述

继承方法

在这里插入图片描述

默认调用父类的无参构造，如果显示写出调用父类的构造器，那么调用父类的构造器，必须要在子类构造器的第一行
重点

super注意点：
- 1. super调用父类的构造方法，必须在构造方法的第一个
- 2. super必须只能出现在子类的方法或者构造方法中！
- 3. super和this 不能同时调用构造方法！因为它们都需要放在构造方法第一个，产生冲突！
与 this 对比：
- 代表的对象不同：
this: 本身调用这个对象
super：代表父类对象的应用
- 前提：
this()：没有继承也可以使用
super()：只有在继承条件下才可以使用
- 构造方法
this(); 本类的构造
super(); 父类的构造

重写，重写都是方法的重写和属性无关

静态方法：方法的调用只和左边定义的数据类型有关

在这里插入图片描述

static去掉之后，重写父类的方法，b.test()输出结果会改变

在这里插入图片描述

重写快捷键

在这里插入图片描述

非静态方法：重写（关键字只能是public）

静态方法和非静态方法区别很大！

静态方法：方法的调用只和左边定义的数据类型有关,
比如B b=new A();这叫做父类的引用指向子类
此时对象能执行哪些方法，主要看对象左边的类型和右边关系不大，它可以指向子类，但不能调用子类独有的方法，例如b不能执行A类（子类）独有的方法比如是test()，如果非要调用的话需要进行调用方法左边类型的强制转换，((A).b).test();
非静态方法：重写父类方法，此时能执行自己的方法或者是调用父类的方法

在这里插入图片描述

重写：需要有继承关系，子类重写父类的方法
1、方法名必须相同
2、参数列表列表必须相同
3、修饰符：范围可以扩大但不可以缩小public>Protected>Default>private
4、抛出的异常：范围可以被缩小但不能被扩大ClassNotFoundException<Exception
重写：子类的方法和父类的方法必要一致，方法体不同
为什么需要重写？
1、父类的方法子类不一定需要或未必满足
Alt+Insert,override;

多态

即同一方法根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型是多变的
多态存在的条件：
1、有继承关系
2、子类重写父类方法
3、父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性

一个对象的实际类型是确定的，可以指向的引用类型就不确定了：父类的引用指向子类

对象能执行哪些方法主要看对象左边的类型和右边关系不大
类能调用的方法都是调用自己的或是继承父类的

在这里插入图片描述

子类一旦重写了父类的方法，执行子类的方法，否则默认执行父类的

在这里插入图片描述

父类可以指向子类，但是不能调用子类独有的方法

在这里插入图片描述

可以强制转换

在这里插入图片描述

多态注意事项

1、多态是方法的多态，属性没有多态
2、父类和子类有联系，类型转换异常 ClassCastException
3、存在条件：继承关系，方法需要重写，父类引用指向子类异常 Father f1=new Son();
不能重写的方法类型有：
1、static 方法属于类不属于实例
2、被final修饰的即是常量，无法重写
3、private方法
多态是方法的多态，属性没有多态
4、子类转换为父类，向上转型
5、父类转换成子类，向下转型：强制转换
6、方便方法的调用，减少重复的代码，提高利用率

instance of (类型转换) 引用类型判断一个对象是什么类型

System.out.println(x instanceof y)能不能编译通过看x与y有无继承关系

在这里插入图片描述

当想要执行子类独有的方法，要进行强制转换

注：go()是Student类独有的方法

相当于
((Student)obj).go();

子类转换为父类可能会丢失自己本来的一些方法

在这里插入图片描述

static 关键字详解

静态变量在类里面共享可以直接通过类来访问，比如Student.age,而非静态变量只能对象来访问，先new一个对象然后通过对象访问。

在这里插入图片描述

静态方法也是，如果是静态方法则在类中是共享的，可以直接调用，如果是非静态方法，需要先new一个对象，然后再调用。
非静态方法可以调用静态方法，静态方法不可以直接调用非静态方法，这是因为静态类比非静态类先加载

在这里插入图片描述

代码块执行顺序

在这里插入图片描述

补充：静态导入包

在这里插入图片描述

5.抽象类和接口

抽象类

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

抽象类的方法由继承他的子类实现，除非子类也是抽象的，就让其子子类去实现

在这里插入图片描述

补充：Java的类是单继承，但是接口是多继承

抽象类特点

1）不能new这个抽象类，只能靠子类去实现它：约束！
2）抽象类中可以写普通的方法
3）抽象方法必须写在抽象类中 // 抽象的抽象:约束

思考题： 1）抽象类存在构造器吗？存在，即使你没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，没有的话你的子类将无法编译，因为在任何构造函数中的第一条语句隐式调用super（）。
2）抽象类存在的意义是什么？比如设计一款游戏，需要为角色赋予功能，很多角色功能都是一样的，这时候把他们抽象成类，直接调用，节省很多代码量。
1.因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护。
2.当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。