面向对象（OOP）学习笔记

最新推荐文章于 2021-05-12 19:37:56 发布

浩浩浩666

最新推荐文章于 2021-05-12 19:37:56 发布

阅读量198

点赞数 1

本文链接：https://blog.csdn.net/a___calf/article/details/105063571

版权

概念

所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者。

面向对象是基于面向过程而言的。

我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）

三大特征

1、封装性
把相关的数据封装成一个“类”组件。
概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
2、继承性（is a的关系），子类自动共享父类的属性和方法，这是类之间的关系。（一个类只能有一个父类，即单继承，继承可以传递）
子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有），又可以自己进行拓展功能，即可以复用以前的代码，又可以在此基础上实现拓展，大大缩短了开发周期，降低了开发费用；
继承的内存图：
在这里插入图片描述
3、多态

 同一个实体同时具有多种形式，增强软件的灵活性和重用性。
  多态主要体现在两个方面：
  （1）引用多态
   *注意： 引用多态的前提是继承*
    父类的引用可以指向本类的对象；也可以引用指向子类的对象。
    用代码体现上述说法，首先创建一个父类Father和一个子类Son，如下

  public static void main（String [] args）{
    Father father = new Father();//父类的引用指向本类  
    //多态中，编译看左边：只能用父类的功能，父类提供调用标准
    //运行看右边：干活看子类，如果子类重写了，就用子类的实现。（父类中的方     //法时private修饰的，子类即使重写（此时就不能叫重写了，只是子类定义了一个相同的方法）了父类的方法，调用的方法运行时是父类的方法，因为private修饰的方法,子类是无法继承的）
    Father son  = new Son();//父类的引用指向子类，小到大，向上转型
   }

注意！！！：只能用父类的引用指向子类，而不能用子类引用指向父类的对象，例如，

Son son = new Father() ; //错误写法

（2）方法多态
注意：方法多态的前提是有方法重写
根据上述创建的两个对象：本类对象和子类对象，同样都是父类的引用，当我们指向不同的对象时，它们调用的方法也是多态的。

创建本类对象时，调用的方法为本类方法；

创建子类对象时，调用的方法为子类重写的方法或者继承的方法；

使用多态的时候要注意：如果我们在子类中编写一个独有的方法（没有继承父类的方法），此时就不
能通过父类的引用创建的子类对象来调用该方法！！！

多态的好处　　
1、多态可以让我们不用关心某个对象是什么具体类型，（直接用父类代替）就可以使用该对象的某些方法。
2、提高了程序的扩展性和可维护性。
多态的特点
1、成员变量：使用的是父类的
2、成员方法：由于存在重写现象所以使用的是子类的
3、静态成员：随着对象而存在，谁调用的就返回谁的
//这个类用来测试多态的使用

public class Test6_Duotai2 {

    public static void main(String[] args) {

       /*//TODO 创建父类对象测试

       Sharp s = new Sharp();

       s.draw();//画个图形

       System.out.println(s.line);//5
       
       //TODO 创建子类对象测试

       Circle c = new Circle();

       c.draw();//画个图形  --   画个圈圈(重写了...)

       System.out.println(c.line);//5

       */

       //TODO 创建多态对象测试

       Sharp s2 = new Circle();

       s2.draw();//画个圈圈，1、多态中的成员方法，运行看右边，用子类的(发生了重写)

       System.out.println(s2.line);//5，2、多态中的成员变量，用父类的

       System.out.println(s2.name);//Sharp，3、静态资源是随着类存在的，哪个类调用就是哪个类的

    }

}

//创建父类

class Sharp{

    int line = 5;

    static String name="Sharp";
    
    public void draw() {

       System.out.println("画个图形");

    }

}

//创建子类

class Circle extends Sharp{

    int line = 10;

    static String name="Circle";


    //重写draw()

    public void draw() {

       System.out.println("画个圈圈");

    }

}

构造方法

1、是与类同名的方法，对象的创建就是通过构造方法来完成的。
2、其主要功能是：完成对象的创建或者对象的初始化。当类实例化new一个对象时回自动调用构造方法。构造方法也可重载，可以有参，也可以无参。
3、子类创建对象时，默认会去访问父类的无参构造方法。
4、在子类构造方法的第一行，会有默认的语句：super（）；或者this（）；，二者不能同时出现，因为他们必须都放在第一行。
5、一个类中只提供有参构造的话，无参构造会被覆盖，就只能通过super调用含参构造。

修饰符  类名(参数列表…){
   代码……

}

this

概念：this代表本类对象的一个引用对象。形式：this.name=name;

应用场景
1、用来区分成员变量和局部变量：成员变量和局部变量的变量名相同时，想要调用成员变量，必须通过this才能调用，否则都是局部变量

2、构造方法间的调用：利用this可以调用本类中其他重载的构造方法。

class Zoo{
    //1、this可以在构造方法间调用
    
    public Zoo(){
    
       //在  无参构造中  调用  含参构造
       
       this("大海豚");
       
       System.out.println("无参构造");
    }

    public Zoo(String name){

       //在  含参构造中  调用  无参构造

       this();//调用了无参构造

       System.out.println("含参构造"+name);

    }

}

super关键字

1、通过super关键字可以使用父类的内容。

2、super代表父类的一个引用对象。

3、如果在构造方法中使用，必须是第一条语句

Override方法重写

1、继承后，子类就拥有了父类的功能。

2、那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能。

3、子类中方法的声明与父类完全一样时，会发生重写/覆盖/复写操作。

4、方法的声明：包括方法的返回值，方法名和参数列表，完全一致。。

注意：

1、父类中的私有方法不能被重写。

2、子类重写父类方法时，修饰符要 >= 父类修饰符的权限。

3、父类中的构造方法不能被子类继承。

静态代码块、构造代码块和局部代码块

静态代码块
1、在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2、类的内部，方法外部。
3、格式如下：
static {
代码。。。
}

构造代码块
1、在类的内部，方法的外部，的代码块。

2、通常用于抽取构造方法中的共性代码。

3、每次调用构造方法前，new都会调用构造代码块，new几次执行几次构造代码块。

4、加载时优先于构造方法。
5、格式如下：
{
语句体
}
局部代码块
1、在方法里的代码块。

2、通常用于控制变量的作用范围，出了括号就失效。

3、变量的范围越小越好，成员变量会有线程安全问题。

4、格式如下：
{
语句体
}
总结
1、构造代码块：在创建对象时，会自动调用构造方法，但是，如果有构造代码块，先执行构造代码块

2、构造方法：在创建对象时，执行完构造代码块，立刻执行构造方法

3、局部代码块：当方法被调用时，才触发。方法如果不调用，局部代码块就不会执行

顺序：构造代码块–>构造方法–>局部代码块

static关键字

概念
是java中的一个关键字，用过修饰成员变量和成员方法。
特点
1、随着类加载而加载。
2、只加载一次，就会一直存在，直到类消失就一起消失。
3、优先于对象加载。
4、被所有对象共享，其中一个修改值，另一个调用的值是被修改过的。
5、static方法可以直接被类名调用。
6、静态只能调用静态。
静态内存图
在这里插入图片描述

final关键字

特点
1、可以修饰类，方法，成员变量。
2、被修饰的类，不能被继承。
3、被修饰的方法，不能被重写。
4、被修饰的变量，是个常量，不能被修改。

常见的修饰符

在这里插入图片描述

异常

继承结构

Throwable - 顶级父类

 -- Error：系统错误，无法修复

 -- Exception：可修复的错误

          --RunTimeException

                 --ClassCastException

                 --ClassNotFoundException

异常处理
两种解决方式：
1、try…catch捕获
2、向上throws抛出

静态变量和实例变量的区别

1、在语法上的定义区别：静态变量前要加static关键字，而实例变量前则不加。
2、在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

抽象类

概念
Java中父类可以定义没有方法体的方法，该方法由其子类来具体实现。该没有方法体的方法，我们称之为抽象方法。含有抽象方法的类我们称之为抽象类。抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
形如：
修饰符 abstract 返回值方法名(参数列表)；
特点

通过java关键字abstract实现。
可以修饰方法或者类。
抽象类中可以没有抽象方法（由子类去实现）/如若一个抽象类中没有抽象方法，意义在于不让外界直接new实例化。
如果类中有有抽象方法，则此类必须为抽象类。
子类继承抽象类之后，只有两个选择，一是子类加上abstract变为抽象类，二是把所有抽象方法都重写。
多用于多态中。
抽象类不可以被实例化。
抽象类的用法
抽象类中的构造方法常用于子类的实例化。抽象类中可以有构造方法，但不是用于自己创建实例，因为抽象父类自己不能创建对象！用来给子类创建对象，通过子类的super调用父类的代码。
抽象类中既可以有变量也可以有常量。
抽象类中可以有普通方法，也可以有抽象方法。
abstract注意事项
1、子类继承抽象类后有两个选择，一是子类加上abstract变为抽象类，二是把所有抽象方法都重写。
2、而抽象方法被继承后要求子类方法必须重写父类方法。有abstract关键字的父类方法不可以添加下列关键字：
（1）private：私有化，致使子类无法重写父类中的方法，与abstract相违背。
（2）final：被final修饰后，无法重写，与abstract相违背。
（3） static：静态的，优先于对象存在。而abstract是对象间的关系，存在加载顺序问题。

接口

概念
Java中是不允许多重继承，如果想要实现多个功能，则可以通过实现多个接口来实现。
Java接口和Java抽象类代表的就是抽象类型，就是我们所需要抽取出来的抽象层的具体表现。
OOP面向对象的编程，如果要提高代码的复用性，增加程序的可维护性，可扩展性，就必须面向接口、面向抽象的编程。
形如：
interface 接口名 {代码…}
特点

接口中都是抽象方法。
利用interface创建接口。
通过implements让子类来实现接口。
接口可以理解为特殊的抽象类。
接口突破了Java的单继承的局限性。
接口和类之间可以多实现，接口和接口之间可以多继承。
接口是对外暴露的规则，是一套开发规范。
接口提高了程序的功能扩展，降低了耦合性。
接口中是没有构造方法的。
在创建接口实现类的对象时默认的super（），是调用的默认Object的无参构造。
接口里没有变量，都是静态常量，会自动为变量拼接public static final。
接口中都是抽象方法，因为会自动拼接public abstract
抽象类型的总结
1、类和类的关系
– 继承关系extends，只支持单继承
– class A extends B
– 其中，A是子类 B是父类
– 方法的重写！
2、类和接口的关系
– 实现关系implments，还可以多实现
– class A implments B,C
– 其中，A是子类 B C是接口
– A 必须重写B C 接口里的所有抽象方法，否则A是抽象类
3、接口和接口的关系
– 继承关系，还可以多继承
– interface A extends B,C
– 其中A B C 都是接口，A接口的功能最全
– class X implments A
– 其中X子类需要重写A B C 里的所有抽象方法
4、抽象类和接口的区别
– 抽象类是一个特殊的类，特殊在抽象类里可以有抽象方法
– 接口是一个特殊的抽象类，特殊在接口里都是抽象方法

5、继承的同时多实现
interface Fu{
}
interface Fu2{
}
class Animal{
}
//创建实现类
//继承的同时多实现
class FuImpl extends Animal implements Fu,Fu2{

接口和抽象类的区别

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。

浩浩浩666

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
面向对象（OOP）学习笔记

概念Thinking in java所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者。面向对象是基于面向过程而言的。我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）三大特征1、封装性，把相关的数据封装成一个“类”组件。概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过...
复制链接

扫一扫