面向对象编程

时间：2021-04-10 22:23:01 收藏：0 阅读：18

1.初识面向对象

面向过程和面向对象比较

面向过程的思想

? 步骤清晰简单，第一步做什么，第二部做什么，面向过程适合处理一些较为简单的问题

面向对象的思想

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

总结：

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

什么是面向对象

? 面向对象编程（Object-Orient Programing, OPP）

? 面向对象的本质：以类的方式组织代码，以对象的方式组织（封装）数据。

抽象

? 怎么样理解抽象，举个例子，一个学生管理系统，里面有学生的姓名，学号，班级，身高，体重等等。我们抽取其中的比如说姓名和学号组成一个类。这是一个对抽象形象的解释。

三大特性

封装：把代码里数据封装起来。

继承：子类可以继承父类的东西。

多态：对同一个方法，不同的事物通过这个方法所得出的结果是不一样的。

? 从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

? 从代码运行的角度考虑是先有类后有对象，类是对象的模板。

1.类与对象

类是一种抽象的数据类型，它是对某一类事物整体的描述、定义，但是并不能代表某一具体的事物。例如：植物，动物.....
对象是抽象概念的具体实例，例如：仙人掌就是植物的一个具体的实例；狗就是动物的一个实例...

2.方法
定义、调用：！
3.对象的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈-->堆

4.属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char： u0000
boolean： false
引用： null

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

5对象的创建与使用

必须使用new 关键字创造对象，构造器 new liuyi Person();
对象的属性 liuyi.name;
对象的方法 liuyi.sleep()

6.类：
静态的属性属性
动态的行为方法

2.类与对象的创建

使用new关键字创建对象

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

创建一个Student类：

package com.oop.demo02;

//学生类  （一个类里面只有属性和方法两样东西）
public class Student {

    //属性：字段
    String name; //null
    int age;  // 0

    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
        //this代表当前这个Student类；
    }

}

实例化对象：

public class Application {
    public static void main(String[] args) {

        //类: 抽象的， 实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例

        Student s1 = new Student();
        Student s2 = new Student();

        s1.name = "张三";
        s1.age = 20;

        System.out.println(s1.name);//张三
        System.out.println(s1.age);//20

        s2.name = "李四";
        s2.age = 19;

        System.out.println(s2.name);//李四
        System.out.println(s2.age);//19
    }
}

3、构造器

类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。一个类即使什么都不写，他也会存在一个方法，即构造方法（构造器）在IDEA中可以通过ALT+Insert快捷键选择生成构造器；并且构造器有两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
构造器的作用
- 使用new关键字，本质是在调用构造器
- 构造器一般用来初始化值
一旦定义了有参构造，无参就必须显式定义，这时调用会根据参数来判断是走无参还是有参

4、创建对象内存分析

5、封装

封装重点是对于属性的封装，方法很少用

该露的露，该藏的藏
- 程序设计要追求”高内聚，低耦合“。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有，get/set

写一个学生类：

public class Student{
    //属性私有
    private String name;//名字
    private int id; //学号
    private char sex;    //性别
   
    //提供一些可以操作这些属性的方法
    //提供一些public的get、set方法
    
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
    
}

main方法：

public class Application{
    public static void main(String[] args){
        Student s1=new Student();
        
        s1.setName("张三");
       
        System,out.println(s1.getName());//张三
        //s1.name在这里不能使用了，因为name是private的，如果换成public则可以使用
    }
}

封装的意义；
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高了系统的可维护性

6、继承

继承的本质是对某一批类的抽象。（类是对对象的抽象，继承是对类的抽象）
extends的意思是“扩展”，子类是父类的扩展。
JAVA中只有单继承，没有多继承。
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系。
子类可以继承父类的所有方法（前提是父类的方法是public修饰的）
调用父类构造器必须要在子类构造器的第一行。
在jiava中，所有的类，都默认直接或间接继承object类

super()注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

VS this:

代表的对象不同：
- this：本身调用者这个对象
- super：代表父类对象的引用
前提：
- this ：没有继承也可以使用
- super：只能在继承条件下才可以使用
构造方法：
- this ()：本类的构造
- super()：父类的构造

7、方法重写

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

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

静态方法和非静态方法区别：

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

8、多态

同一对象可以根据发送对象的不同而采用多种不同的行为方式.
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态的存在条件
- 有继承的关系
- 子类重写父类的方法
- 父类引用指向子类对象
注意：
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系类型转换异常，ClassCastException
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 =new Son
不能被重写的方法：
- static 方法，属于类，它不属于实例
- final 常量：
- private方法

9、instanceof和类型转换

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型：
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码！

10、static关键字

11、抽象类

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

12、接口的定义与实现

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范约束和实现分离
接口就是规范，定义的一组规则
接口的本质是契约，就像人类定义的法规一样，制定好后大家都要遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口，声明类的关键字是class，声明接口的关键字是interface

java是单继承的，但是可以通过接口实现多进程

两个接口：

package com.oop.demo10;

public interface TimeService {
    void timer();
}

package com.oop.demo10;

//interface 定义的关键字  ,接口都需要有实现类
public interface UserService {

   //常量~ public static final
   int AGE = 99;

   //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);
}

接口的实现：

package com.oop.demo10;

//抽象类 extends
//类 可以实现接口 implement 接口
//实现了接口的类，就需要重写接口中的方法

//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口的作用：
- 约束
- 定义一些方法，让不同的人实现
- 方法都是 public abstract
- 常量都是常量~ public static final
- 接口不能被实例化，接口中没有构造方法
- implements 可以实现多个接口
- 必须要重写接口中的方法

13、内部类

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

内部类可分为：

成员内部类

package com.oop.demo11;

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(id);
    }
  }
}

package com.oop;

import com.oop.demo11.Outer;

public class Application {
    public static void main(String[] args) {
        //new

        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }

}

静态内部类
局部内部类
- 写在方法中的类

匿名内部类

package com.oop.demo11;

public class Test {
    public static void main(String[] args) {
      //没有名字初始化类,不用将实例保存在变量中
        new Apple().eat();
    }
}
class Apple{
    public void eat(){
    
    }
}

原文：https://www.cnblogs.com/ly1372/p/14641611.html