面向对象学习

面向对象

概念思想

• 物以类聚，分类的思维方式。
• 元素加方法就是类
• 面向对象编程（Object-Oriented Programming，OOP）。
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

类和对象的关系

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
• 对象是抽象概念的具体实例

对象创建分析

• 使用new创建对象
• 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化 以及对类中构造器的调用。
• 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。构造器有以下俩个特点：
  • 必须和类的名字相同
  • 必须没有返回类型，void都不能有

package com.zy.OOP;
//Person类
public class Person {

    //属性
    String name;
    int age;

    //方法
    public void printname()
    {
        System.out.println("name:" + this.name);
    }
}

package com.zy.OOP;
//测试类，每个项目里就只留一个类中有main方法
public class Application {

    public static void main(String[] args) {
        Person person = new Person();//创建对象
        Person person1 = new Person();

        person.name = "xiaoming";//给对象里的元素进行赋值
        person.age = 16;

        person1.name = "xiaohong";
        person1.age = 15;

        person.printname();//用对象调用类中的方法
        person1.printname();
    }
}

构造器

• 就是构造方法
• 有两种构造方法
  • 无参构造 （没有写构造方法时，会默认有一个无参的空的构造方法也就是构造器）
  • 有参构造（定义了有参构造后，就不会默认一个无参构造，必须自己写一个无参构造方法）
• 构造器的功能就是用来初始化数据

面向对象三大特征

• 封装

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

• 继承

  • 继承本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extends的意思是“扩展”。子类是父类的扩展。
  • Java中类只有单继承，没有多继承！
  • 继承是类和类之间的关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
  • 子类和父类之间，从意义上讲应该具有“ is a”的关系。
  • Java中所有类默认继承object类(直接或者间接)
  • super（它调用的就是继承的父类中的构造方法，只能在子类的方法或者构造方法中出现），this（它后面就是本类中的方法或者变量）
  • 使用super或者this调用构造器时，必须是在第一行，不能同时调用构造方法。this();本类的构造，super()父类的构造

  package com.zy.demo00;
  //父类
  public class Person {
      private String name;
      private int age;
  
      public void say(){
          System.out.println("说了一句话。");
      }
  }
  
  

  package com.zy.demo00;
  //Student类继承了Person类
  public class Student extends Person{
  
  
  }
  
  

  package com.zy.demo00;
  //测试类
  public class Test {
      public static void main(String[] args) {
  
          Student student = new Student();
          student.say();//子类对象可以直接调用父类中的方法
      }
  }
  
  

  • 重写（重写是方法的重写，子类重写父类的方法，就是在子类写和父类一样的方法，只是更改了执行语句）
    • 修饰符的范围可以扩大，不能缩小（public > protected>default>private）
    • 抛出的异常的范围可以变小，不能变大。

• 多态

  • 动态编译：类型
  • 既同一个方法可以根据发送对象的不同而采用多种不同的行为方式。
  • 一个对象的实际类型确定的，但可以指向对象的引用的类型很多。
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象
  • 多态是方法的多态，属性没有多态性

  Person s1 = new Student();//父类引用指向子类对象
  //Student继承Person
  //s1调用的是Person已有的方法，不能直接调用Student中新写的方法，重写的方法可以直接调用
  

  • instanceof（判断是否存在父子关系）

System.out.println(X instanceof Y);//有就输出true，没有就输出false，X为子，Y为父

抽象类

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

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…“的思想。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
• 接口的本质是契约，就像我们人间的法律。制定好后大家必须遵守。
• OO的精髓就是对对象的抽象，最能体现这一点的就是接口。
• interface就是声明接口的关键字

public interface Say {
    void add(int a,int b);//接口中方法都是public abstract
}

public class A implements Say{

    @Override
    public void add(int a, int b) {
        System.out.println(a+b);
    }
}

• implements就是继承接口的关键字，可以同时继承多个接口，同时子类要实现接口中所有的方法。
• 接口中的常量默认都是静态常量

public interface Say {
    int age = 12;//接口中常量都是public static fianl
}

内部类

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

• 成员内部类

• 静态内部类（加了static修饰符）

• 局部内部类（写在方法里）

• 匿名内部类（没有名字初始化类，不用将实例保存在变量中）

• 内部类可以访问外部类的私有属性，静态类只能访问静态。

• 一个Java文件中只能有一个public class类。