面向对象基础

Angel__wings

已于 2024-03-03 19:20:11 修改

阅读量655

点赞数 25

文章标签： 1024程序员节

于 2024-03-03 15:46:17 首次发布

本文链接：https://blog.csdn.net/Angel__wings/article/details/127489981

版权

OO;面向对象

OOA:面向对象分析

OOD:面向对象设计

OOP;面向对象编程

什么是类？什么是对象？

现实生活中是由很多很多对象组成的，基于对象抽出了类

对象：软件中真实存在的单个个体/东西

类：类别/类型，代表一类个体

类是对象的模子，对象是类的具体的实例

类中可以包含：

对象的属性/特征-----------------------成员变量
对象的行为/动作-----------------------方法
一个类可以创建多个对象

方法的重载(overload/overloading)：---------------更加方便用户的访问

发生在同一类中，方法名相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定方法
复用性好、扩展性好、维护性好、可移植性好\健壮性好、可读性好、效率好…

方法的签名：方法名+参数列表

默认规则:
byte,short,int,long,char----------默认值 0
float,double-------------------------默认值 0.0
boolean------------------------------默认值 false
引用类型-----------------------------默认值 null

//若想访问对象，需要通过引用zs
引用
数据类型引用类型变量指向对象
Student zs = new Student();

构造方法：构造函数、构造器、构建器---------复用给成员变量赋初值代码
作用：给成员变量赋初始值
与类同名，没有返回值类型(连void都没有)
在创建(new)对象时被自动调用
若自己不写构造方法则编译器默认提供一个无参构造方法:若自己写了构造方法，则不再默认提供

(重载与返回值类型无关)(重载与参数名称无关)
构造方法可以重载

this 只能用在方法中方法中访问成员变量之前默认有个this
this：指代当前对象，哪个对象调用方法它指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this.

this的用法：
this.成员变量名-------------访问成员变量

成员变量与局部变量同名时，若想访问成员变量则this不能省略

this.方法名()-----------------调用方法(了解)
this()---------------------------调用构造方法(了解)

null：表示空，没有指向任何对象若引用的值为null，则该引用不能进行任何点操作了，若操作则发生NullPointerException空指针异常

成员变量：写在类中，方法外--------有默认值
局部变量：方法中------------------------没有默认值

成员变量和局部变量是可以同名的：
----使用的时候默认采取就近原则
----若想访问成员变量，则this不能省略

内存管理：由JVM来管理的

https://mp.csdn.net/mp_blog/creation/editor/136351864

堆：new出来的对象(包括成员变量)
栈：局部变量(包括方法的参数)

数组也是一个对象，所以数组对象也存储在堆中，
将数组的元素当作成员变量一并存储在堆中

引用类型数组：

与基本类型数组的区别：
给数组元素赋值必须new一下
若想访问对象数据必须通过数组元素打点

System.out.println (stus[0].name);//输出第1个学生的名字//2)访问数据需要通过数组元素打点

stus[1].age = 24;//修改第二个元素的年龄为24

继承：(要符合is(是)的关系

作用：代码复用
通过extends来实现继承
超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
派生类既能访问自己的，也能访问超类，但是超类不能访问派生类的
一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承
具有传递性

继承的是超类的成员变量和普通方法,而不包括构造方法,

构造方法是被派生类通过supper来调用的

java规定：

构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
super()调用超类构造方法，必须位于派生类构造方法的第1行

super：指代当前对象的超类对象

super的用法:

super.成员变量名---------------------访问超类的成员变量
super.方法名()-------------------------调用超类的方法
super()-----------------------------------调用超类的构造方法

向上造型：

超类型的引用指向派生类的对象
能点出来什么，看引用的类型

向上造型的意义：--------实现代码复用
- 当多种角色能干的事是一样的，可以将那多种角色造型到超类数组中，统一访问

方法的重写：重新写

发生在父子类中，方法名相同，参数列表相同
重写方法被调用时，看对象的类型
重写遵循"两同两小一大"原则

两同：
方法名相同
参数列表相同
两小：
派生类方法的返回值类型小于或等于超类方法的
void和基本类型时，必须相等
引用类型时，小于或等于
派生类方法抛出的异常小于或等于超类方法的
一大：
派生类方法的访问权限大于或等于超类方法的

重写与重载的区别：

重写(override)：发生在父子类中，方法名相同，参数列表相同
---用于在派生类中修改超类中所声明的方法
重载(overload)：发生在同一类中，方法名相同，参数列表不同
---完全不同的方法,只是方法名正好相同

import javax.swing.*;

public class World extends JPanel {
    public static void main(String[] args) {

        JFrame frame = new JFrame();
        World world = new World();
        world.setFocusable(true);
        frame.add(world);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(641+16, 479+39);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

package和import：

package：声明包

避免类的命名冲突
同包中的类不能同名，但不同包中的类可以同名
类的全称：包名.类名
包名常常用层次结构，建议所有字母都小写

import：导入类

同包中的类可以直接访问
不同包中的类不能直接访问，若想访问：
先import声明类，再访问类
类的全称
访问控制修饰符：---保证数据的安全

public：公开的，任何类 (行为{方法})
private：私有的，本类 (数据{成员变量})
protected：受保护的，本类、派生类、同包类
默认的：什么也不写，本类、同包类

说明：
- 类的访问权限只能是public或默认的
- 类中成员的访问权限如上4种都可以
- 访问权限由高到低依次为：public>protected>默认的>private

成员变量

实例变量:没有static修饰,属于对象的,存储在堆中,有几个对象就有几份

通过引用(对象)点来访问

静态变量:由static修饰,属于类的,存储在方法区中,只有一份

通过类名点来访问

final：最终的、不可改变的

修饰变量：变量不能被改变
修饰方法：方法不能被重写
修饰类：类不能被继承

static：静态的

public static void main(String[] args){
        Loo o1 =new Loo();
        o1.show();
        Loo o2 =new Loo();
        o2.show();
        Loo o3 =new Loo();
        o3.show();
}
//演示静态变量

class loo{

    int a;
    static int b;
    Loo(){
        a++;
        b++;    
            }
    void show(){
        System.out.println("a="+a+",b="+b);}

}

静态变量：
- 由static修饰
- ```
int a;//实例变量(通过对象来访问)
static int b;//静态变量(通过类名来访问)
```
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据(图片、音频、视频等)

public static void main(String[] args){
        Loo o1 =new Loo();
        o1.show();
        Loo o2 =new Loo();
        o2.show();
        Loo o3 =new Loo();
        o3.show();
}
//演示静态变量

class loo{

    int a;//实例变量(对象点来访问)
    static int b;//静态变量(类名点来访问)
    Loo(){
        a++;
        b++;    
            }

    void show(){//有隐式this
        System.out.println(this.a);
        System.out.println(Loo .a);}

    Static void test(){//没有隐式this
            //静态方法中没有隐式this传递
            //没有this意味着没有对象
            //而实例变量a必须通过对象名点来访问
            //所以如下代码发生编译错误 
            System.out.printle(a);//编译错误
             System.out.printle(Moo.a);


}

静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法中没有隐式this传递，不能直接访问实例成员
- ---(普通方法(有隐式this))---
- 何时用：方法的操作与对象无关
静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次
- 何时用：加载/初始化静态资源(图片、音频、视频等)

静态块: 初始化静态变量

构造方法: 初始化实例变量

数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
成员变量分两种：
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
通过引用(对象)点来访问
静态变量：由static修饰，属于类的，存储在方法区中，只有一份
通过类名点来访问
内存管理：由JVM来管理
堆：new出来的对象(包括实例变量)
栈：局部变量(包括方法的参数)
方法区：.class字节码文件(包括静态变量、所有方法)

static final常量：

必须声明同时初始化
类名点来访问，不能被改变
建议：常量名所有字母都大写，多个单词用_分隔
编译器在编译时会将常量直接替换为具体的数，效率高
何时用：数据永远不变，并且经常使用

设计规则:

将共有的属性和行为,抽到超类中 --------抽共性

若对象行为都一样,设计为普通方法,

若行为对象不一样,设计为抽象方法

抽象方法：

由abstract修饰
只有方法的定义，没有具体的实现(连{}都没有)

抽象类：

由abstract修饰
包含抽象方法的类必须是抽象类, 抽象类不能被实例化(new对象), 抽象类是需要被继承的，

派生类：
重写所有抽象方法-----------------变不完整为完整
也声明为抽象类---------------------一般不这么用
抽象类的意义：
封装共有的属性和行为---------------代码复用
为所有派生类提供统一的类型------向上造型
可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，
派生类的行为不同，但入口是一致的，同时相当于定义了一个标准(强制重写)

设计规则：
将共有的属性和行为，抽到超类中-------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法

抽象方法/抽象类的疑问:
抽象方法存的意义是什么？
保证当发生向上造型时，通过超类的引用能点出来那个方法
既然意义只在于能点出来，那为什么不设计为普通方法呢？
若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写

没有抽象方法的类也可以声明抽象类,只要是抽象类一定不能实例化

成员内部类：应用率低-
类中套类，外面的称为外部类，里面的称为内部类
内部类通常只服务于外部类，对外不具备可见性
内部类对象通常在外部类中创建
内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this-

匿名内部类：---大大简化代码

若想创建一个类(派生类)的对象，并且对象只被创建一次，可以做成匿名内部类
在匿名内部类中默认外面的变量为final的隐式的引用：

内部类有独立的.class

this：指代当前对象
super：指代当前对象的超类对象
外部类名.this：指代当前对象的外部类对象

做功能的套路：
1)先写行为/方法：
2)若为某对象所特有的行为，则将方法设计在特定的类中
3)若为所有对象所共有的行为，则将方法设计在超类中
窗口调用：
若为定时发生的，则在定时器中调用
若为事件触发的，则在侦听器中调用

接口：

是一种引用数据类型
由interface定义
只能包含常量和抽象方法
接口不能被实例化(new对象)
接口是需要被实现/继承的，实现类/派生类：
----必须重写所有抽象方法
一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现
接口可以继承接口

关系：
类和类---------------------继承extends
接口和接口---------------继承extends
类和接口------------------实现implements
设计规则：
将所有派生类所共有的属性和行为，抽到超类中---------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法
将部分派生类所共有的属性和行为，抽到接口中
接口是对继承的单根性的扩展---------------------------实现多继承
接口的意义：
实现多继承
制定了一套标准、规则

多态：
意义：
同一类型的引用指向不同的对象时，有不同的实现--------所有抽象方法都是多态的
----行为的多态：cut()、getImage()、move()…
        同一个对象被造型为不同的类型时，有不同的功能--------所有对象都是多态的
----对象的多态：我、你、水…
向上造型/自动类型转换：
        超类型的引用指向派生类的对象
        能点出来什么，看引用的类型
        能造型成为的数据类型有：超类+所实现的接口
        强制类型转换，成功的条件只有如下两种：
        引用所指向的对象，就是该类型
        引用所指向的对象，实现了该接口或继承了该类
        强转时若不符合如上条件，则发生ClassCastException类型转换异常
        建议在强转之前先通过instanceof判断引用的对象是否是该类型

面向对象三大特征：

封装
类：封装的是对象的属性和行为
方法：封装的是具体的业务逻辑功能实现
访问控制修饰符：封装的是具体的访问权限，以保护数据的安全
继承：
作用：代码复用
超类：所有派生类所共有的属性和行为
接口：部分派生类所共有的属性和行为
派生类：派生类所特有的属性和行为
单一继承、多接口实现，具有传递性
多态：
行为多态：所有抽象方法都是多态的(通过方法的重写实现的)
对象多态：所有对象都是多态的(通过向上造型来实现)
向上造型、强制类型转换、instanceof判断

Angel__wings

关注

25
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
面向对象基础

super()-----------------------------------调用超类的构造方法。boolean------------------------------默认值 false。接口是对继承的单根性的扩展---------------------------实现多继承。引用类型-----------------------------默认值 null。this()---------------------------调用构造方法(了解)
复制链接

扫一扫