面向过程&面向对象

  • 面向过程
    • 步骤简单清晰，第一步做什么，第二部做什么
    • 面向过程适合处理一些较为简单的问题
  • 面向对象思想
    • 物理类聚，分类的思考模式，思考问题首先会拒绝问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题

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

    什么是面向对象

  • 面向对象编程(Object-Oriented Programming. OOP)

  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
  • 抽象
  • 三大特性
    • 封装
    • 继承
    • 多态
  • 从认识论角度考虑实现有对象后有类。对象是具体的事物；类是抽象的是对对象的抽象

  • 从代码运行角度考虑不是现有类后有对象。类是对象的模板

    类与对象的关系

  • 类是一种抽象的数据类型，他是某一事物整体描述/定义，但是不能代表某一事物

  • 对象是抽象概念的具体实例

    创建与初始化对象

  • 使用new关键字创建对象

  • 使用new创建此创建的时候，除了分配内存空间之外，还会给’创建好的对象’经i选哪个默认的初始化及’对类中构造器的调用’ ```java //学生类 public class students { //属性：字段 String name; int age;

    //方法 public void study(){

    1.   System.out.println(this.name+"在学习");

    } }

  1. ```java
  2. //一个项目应该只存在一个main方法
  3. public class application01 {
  4.     //:抽象的，实例化
  5.     //类实例化后会返回一个自己的对象
  6.     //student独享就是一个Student类的具体实例
  7.     public static void main(String[] args) {
  8.         students XYH = new students();
  9.         students YJD = new students();
  10.         XYH.age = 25;
  11.         XYH.name ="狗男人";
  12.         System.out.println(XYH.name+"胥尹辉今年"+XYH.age);
  14.     }
  16. }
  • 类中的构造器也成为构造方法，是在进行创建对象时候的必须调用的。并且构造器有以下两个特点:
    1. 必须和类的名字相同
    2. 必须没有返回类型，也不能写void
  • 构造器必须掌握

    类与对象小结

    ```java public class incloution { /*
    • 1.类与对象
    • 类是一个模板：抽象
    • 对象是一个具体的实例
    • 2.方法
    • 定义、调用
    • 3.对象的引用
    • 引用类型： 基本类型（8种）
    • 对象是通过引用来操作的：栈—->堆
    • 4.属性：字段Field/成员变量
    • 默认初始化：
    • 数字：0 0.0
    • char： u00000
    • boolaean：false/true
    • 引用：null
    • 修饰符 属性类型 属性名 = 属性值
    • 5.对象的创建和使用
    • a.必须使用new 关键字创造对象。构造器 Person yangjida = new Person（）；
    • b.对象的属性 yangjida.name
    • c.对象的方法 yangjida.study()
    • 6。类：
    • 静态的属性 属性
    • 动态的行为 方法
    • */

}

  1. <a name="biDKg"></a>
  2. # 封装
  4. - 该露的露。该藏得藏
  5.    - 我们设计程序追求“**高内聚、低耦合**”。高类聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量方法给外部使用
  6. - 封装（数据的隐藏）
  7.    - 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这被称为信息隐藏
  8. - 属性私有，**get/set**
  9. ```java
  10. /*
  11. 1.提高程序的安全性，保护数据
  12. 2.隐藏代码的实现细节
  13. 3.统一接口
  14. 4.增加系统的可维护性*/
  1. package JavaSE.Java基础语法.src.oop.demo02;
  3. public class student {
  4.     //属性私有
  5.     private String name;
  6.     private int id;
  7.     private char sex;
  8.     private int age;
  10.     public int getAge() {
  11.         return age;
  12.     }
  14.     public void setAge(int age) {
  15.         if (age<=0 || age>200){
  16.             this.age = 3;
  17.         }else{
  18.             this.age = age;
  19.         }
  20.     }
  22.     //提供一些可以操作这个属性的方法
  23.     //提供一些public的get/set方法
  24.     //get  获得这个数据
  25.     public String getName() {
  26.         return this.name;
  27.     }
  29.     //set 给这个数据设置值
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public int getId() {
  35.         return this.id;
  36.     }
  38.     public void setId(int id) {
  39.         this.id = id;
  40.     }
  42.     public char getSex() {
  43.         return sex;
  44.     }
  46.     public void setSex(char sex) {
  47.         this.sex = sex;
  48.     }
  49. }
  1. package JavaSE.Java基础语法.src.oop;
  3. import JavaSE.Java基础语法.src.oop.demo02.student;
  5. public class application {
  6.     public static void main(String[] args) {
  7.         student s1 = new student();
  8.         s1.setName("YJD");
  9.         System.out.println(s1.getName());
  10.         s1.setId(2018086236);
  11.         System.out.println(s1.getId());
  12.         s1.setAge(588);
  13.         System.out.println(s1.getAge());
  14.         s1.setSex('男');
  15.         System.out.println(s1.getSex());
  16.     }
  17. }

继承

  • 继承的本质是对某一批类的抽象，从而实现对现实更好的建模
  • extends的意思是“扩展”。子类是父类的拓展
  • Java中类只有单继承，没有多继承
  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系海域以来、组合、聚合等
  • 继承关系的两个类。一个为子类，一个为父类。子类继承父类，使用关键字extends来表示
  • 子类与父类之间，从意义上来讲应具有“is a”的关系
  • object类
    • 在Java章，所有的类，都陌路人继承object
  • super
    1. super调用父类的构造方法，必须在构造方法的第一个
    2. super必须只能出现在子类的方法或者构造方法中
    3. super和this不能同时调用构造方法
    4. 和this的区别
      1. 代表对象不同：
        1. this：本身调用者这个对象
        2. super：代表父类父对象的应用
      2. 前提：
        1. this：没有继承也可以使用
        2. super：只能在继承条件才能使用
      3. 构造方法：
        1. this（）：本类的构造
        2. super（）：父类的构造
  • 方法重写：需要有继承关系，子类重写父类的方法
    • 方法名必须相同
    • 参数列表必须相同
    • 修饰符：范围可以扩大
    • 抛出的异常：范围可以被缩小，但不能被扩大
    • 我们为什么需要重写
      1. 父类的功能，子类不需要或者不满足
      2. Alt + Insert : override
  • 方法重载：方法重载指的是同一个类中定义多个同名方法，这些同名方法的参数个数和类型不同，返回类型和存取权限可以不同

方法重写：方法重写指的是有继承关系的子类继承父类中的方法并定义不同的方法体，子类和父类中的方法 名和参数个数类型要完全一样，是一种覆盖。

多态

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定，但可以指向对象的引用类型有很多
  • 多态存在的条件：
    1. 有继承关系
    2. 子类重写父类的方法
    3. 父类引用指向子类对象
  • 多态是方法的多态，属性没有多态 ```java import JavaSE.Java基础语法.src.oop.demo06.Person; import JavaSE.Java基础语法.src.oop.demo06.Student;

public class application { public static void main(String[] args) { //能调用的都是子类本身自己的方法或者从父类继承来的方法 Student s1 = new Student(); //父类可以指向子类，但是不能调用子类独有的方法 Person s2 = new Student(); // 父类的引用指向了子类 Object s3 = new Student(); s2.run();//子类重写了父类的方法 s1.run(); s1.eat(); } }

  2. - instanceof     （类型转换）  引用类型
  3.    - 强制转换
  4. <a name="r11O9"></a>
  5. # 抽象类
  7. - abstract修饰符可以用来修饰方法也可以用来修饰类，入伙修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
  8. - 抽象类中可以没有抽象方法，但是抽象方法的一定要生命为抽象类
  9. - 抽象类，不能使用new关键之来创建对象，它是用来让子类继承的。
  10. - 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
  11. - 子类继承抽象类，那么就必须实现抽象类没有实现的抽象方法，否则该子类也要声明抽象类
  12. ```java
  13. //abstract  抽象类
  14. public abstract class Action {
  16.     //约束~  希望有人帮我们实现
  17.     //abstract，抽象方法，只有方法名字，没有方法的实现！
  18.     public abstract void dosomething();
  20.     /*
  21.     * 1。不能new抽象类，只能靠子类去实现它—————约束！
  22.     * 2.抽象类里可以写普通方法
  23.     * 3.抽象方法必须在抽象类中
  24.     * 抽象的意义：提高开发效率，提高代码的复用率*/
  26. }

接口

  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）
  • 接口：只有规范！自己无法写方法
  • 接口就是规范，定义的是一组规则
  • 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
  • OO的精髓，就是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对了具备抽象能力的语言，就是因为设计模式所研究的，实际上即使如何合理的抽象

FIRST

  1. public interface UserService {
  2.     //接口中所有的定义其实都是抽象的
  3.     //public abstract
  4.     void add(String name);
  5.     void delete(String name);
  6.     void update(String name);
  7.     void query(String name);
  10. }

SECOND

  1. public interface TimeService {
  2.     void timer();
  3. }

THRID

  1. //一个类可以实现接口  implements
  2. //实现了接口中的类，就需要重写接口中的方法
  3. //利用接口实现多继承
  4. public class UserSeviceImpl implements UserService,TimeService{
  5.     @Override
  6.     public void add(String name) {
  8.     }
  10.     @Override
  11.     public void delete(String name) {
  13.     }
  15.     @Override
  16.     public void update(String name) {
  18.     }
  20.     @Override
  21.     public void query(String name) {
  23.     }
  25.     @Override
  26.     public void timer() {
  28.     }
  29. }

作用

  1. 约束
  2. 定义一些方法，让不同的人实现
  3. public abstract
  4. public static final
  5. 接口不能被实例化，因为接口中没有构造方法
  6. implement可以实现多个接口
  7. 必须要重写接口中的方法

    内部类

    内部类就是在一个类的内部定义的一个类，比如A类中定义一个B类，那么B类相对于A类来说就被称为内部类，而A类就被B类称为外部类
  • 成员内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类