面向对象OOP学习笔记

Fzzfxx

已于 2022-06-16 23:52:04 修改

阅读量70

点赞数

分类专栏： JAVA基础文章标签：学习 java 开发语言

于 2022-06-16 23:51:07 首次发布

本文链接：https://blog.csdn.net/Fzzfxx/article/details/125325338

版权

JAVA基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

面向对象OOP

Object Oriented Programming

高内聚低耦合，是软件工程中的概念，是判断软件设计好坏的标准，主要用于程序的面向对象的设计，主要看类的内聚性是否高，耦合度是否低。

面向对象的特点：

1.封装性：

API：应用程序编程接口

封装性所需要实现的最基本的目标是实现“高内聚、低耦合”的“最佳状态”

设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。

2.继承性：

Java语言规范中，java编译器会根据一个方法的名字参数的数目和类型检查方法的重载不包含返回类型参数名抛出异常

在理想的情况下，一个具体的Java类应当只实现Java接口和抽象Java类中声明的方法，而不应当给多余方法。

构造器：

父类的构造器不可被子类继承

一旦显式定义了构造器，则系统不再提供默认构造器。定义显示构造器方法如下

构造器一般写在属性和方法之间，与类名相同

class AAA{
    int aa;
    String bb;
    //构造器
    public AAA(){
        System.out.println("这里可进行赋值操作，或是输出语句之类，当构造器在被调用时，即新建对象就会执行");
    }
    public AAA（ int aa,String bb）{
        this.aa=aa;
        this.bb=bb;
    }
}
class test{
    public static void main(String[] args) {
    AAA p=new AAA(1,"阿萨德");  //  AAA() 即为调用构造器  这时会执行 上面写的构造器 
    }
}
//构造器和类名相同 
//无返回 void也无 不能有return
//不能被static、final、abstract、native、synchronized修饰
//一旦显式定义了构造器，则系统不再提供默认构造器

如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。

抽象类：

抽象类和抽象方法使用abstract关键字声明。一个类包含抽象方法，那么这个类必须为抽象类。抽象类中可以有普通类。继承时必须实现抽象方法

接口：

接口的方法只能是抽象的和公开的

接口支持多继承

接口不能有构造器

可以看作是一个纯抽象类。不能有任何实现方法，但是java8之后可以有默认实现方法用default 加方法以及实现

default a(){
    System.out.println("");
} //接口中的方法实现

3.多态性：

方法重写：

override

发生在子类与父类之间

非静态方法属于类的实例，是可以被子类重写，从而达到多态的效果；静态方法属于类，是不能被重写，故而也不能实现多态。

当一个子类继承一个父类时，它同时继承了父类的属性和方法。子类可以直接使用父类的属性和方法，如果父类的方法不能满足子类的需求，则可以在子类中对父类的方法进行重写（或覆盖）。

方法重写返回值和形参都不能改变

public class test01 {
    public static void main(String[] args) {
        bb x=new bb();
        x.a();
        x.print("阿萨德"); // 这是重写后的print
    }
/*   输出结果
这是父类1	bb
1bb
这是父类1	bb
这是子类
*/
 }
 class aa{
    int a=1;
    String b="bb";
    public int print(String c){    //返回值 int  形参 String
        System.out.println("这是父类"+a+"\t"+b);
        return 1;
    }
 }
 class bb extends aa{

    public void a(){
        super.print("阿萨德");     //用的是父类中的print 没有被子类中的方法重写影响   super关键字调用父类方法
        System.out.println(a+b);
    }
    public int print(String b){		//返回值 int  形参 String
        super.print("阿萨德");			//用的是父类中的print 没有被子类中的方法重写影响
        System.out.println("这是子类");
        return 0;
    }
 }

方法重载：

overload

方法重载发生在同一个类中，他们的方法名一样，返回值类型和修饰符可以一样也可以不一样

但是参数列表必须不一样

具体表现为：

参数个数不同

参数列表内容不同

参数列表顺序不同如下图中方法1和方法4

public class test01 {

    public static void main(String[] args) {
        chongZai c=new chongZai();
        c.fun();
    }


 }
 class chongZai{
    public String fun(String index1,int index2,double index3){
        System.out.println(index1+"\t"+index2+"\t"+index3);

        return "方法1";
    }
    public String fun(){
        return"方法2";
    }

    public int fun(int index1){
        System.out.println("方法3");
        return 1;
    }
    public String fun(int index1,String index2,double index3){
        return "方法4";
    }
 }