小白-面向对象

面向对象

1. 什么是面向对象

  面向对象编程的本质：
        以类的方式组织代码，以对象的组织（封装）数据。
  面向对象三大特征：
        封装、继承、多态
  面向过程思想：
        步骤清晰简单。
        面向过程适合处理一些较为简单的问题。
  面向对象思想：
        物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思考。
        面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

2. 类与对象的关系

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

创建与初始化对象

  使用new关键字创建对象。
  使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
  类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有一下两个特点：
        1.必须和类的名字相同。
        2.必须没有返回类型，也不能写void
  实例：Student
  package com.wyz.oop.demo01;
  public class Student {
      //属性，字段
      String name;
      int age;
      //方法
      public void study(){
          System.out.println(this.name+"学生在学习");
      }

  }
  实例：Application
  package com.wyz.oop.demo01;
  public class Aplication {
      //一个项目只存一个main方法
      public static void main(String[] args) {
          //类是抽象的，需要实例化
          Student s = new Student();
          s.name = "小明";
          s.age = 20;
          System.out.println(s.name);
          System.out.println(s.age);
      }
  }
  构造器实例：Person
  package com.wyz.oop.demo01;
  public class Person {
      //一个类即使什么都不写，它也会存在一个方法
      //显示的是定义构造器
      String name;
      //实例化初始值
      //1.使用new关键字，本质是在调用构造器
      //构造器一般用来初始化值
      public Person(){
          this.name = "xiaohua";
      }
      //有参构造
      //一旦定义有参构造，无参构造就必须显示定义，否则无效
      public Person(String name){
          this.name = name;
      }
  }
  构造器实例：启动类
  package com.wyz.oop.demo01;
  public class Aplication {
      //一个项目只存一个main方法
      public static void main(String[] args) {
          Person person = new Person();
          System.out.println(person.name);
      }
  }
  注意：生成构造器快捷Alt + Insert

3. 类与对象的简单小结

  1.类与对象
        类是一个模板，抽象，对象是一个具体的实例
  2.方法
        定义、调用
  3.对应的引用
        引用类型、基本类型
        对象是通过引用来操作的：栈--->堆
  4.属性：字段Field 成员变量
  5.对象的创建和使用
        必须使用new 关键字创造对象，构造器  Person p = new Person();
        对象的属性 p.name
        对象的方法 p.sleep()
  6.类：
        静态的属性  属性
        动态的行为  方法

4. 封装

  高内聚，低耦合   属性私有 get/set
  实例：
  package com.wyz.oop.demo01;
  public class Test {
      //属性私有
      private String name;
      private int id;
      private int age;
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          if (age>100||age<0){
              this.age=0;
          }else{
              this.age=age;
          }
      }
      //提供一些可以操作这个属性的方法
      //提供一些public的get、set方法
      //get获得这个数据
      public String getName() {
          return name;
      }
      //set给这个数据设置值
      public void setName(String name) {
          this.name = name;
      }
      public int getId() {
          return id;
      }
      public void setId(int id) {
          this.id = id;
      }
  }
  实例：启动类
  package com.wyz.oop.demo01;
  public class Aplication {
      //一个项目只存一个main方法
      public static void main(String[] args) {
          Test t = new Test();
          t.setName("二二");
          System.out.println(t.getName());
          t.setAge(90);
          System.out.println(t.getAge());
      }
  }
  封装特点：
        1.提高程序的安全性，保护数据。
        2.隐藏代码的实现细节。
        3.统一接口。
        4.提高系统可维护性。

5. 继承

  继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  extends的意思是扩展，子类是父类的扩展。
  Java类中只有单继承，没有多继承。
  继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  继承关系的两个类，一个是子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示。
  子类和父类之间，从意义上讲应该具有“is a”的关系。
  实例：
  Person类：父类
  public class Person {
      //如果把public改成private，私有，就不能被继承
      public int money = 10_0000_0000;
      //private int money = 10_0000_0000;
      public void say(){
          System.out.println("我是人！！");
      }
  }
  Teacher类：子类
      //子类继承父类就有父类的全部方法
  public class Teacher extends Person{
  }
  Aplication类：启动类
  public class Aplication {
      //一个项目只存一个main方法
      public static void main(String[] args) {
          Teacher teacher = new Teacher();
          teacher.say();
          System.out.println(teacher.money);
      }
  }

Super详解

  实例：
  Person类：父类
  public class Person {
      public Person() {
          System.out.println("Person无参构造");
      }
      protected String name = "muchen";
      //如果把public改成private，将不能被继承
      public void print(){
          System.out.println("Person");
      }
      }
  Student类：子类
  //子类继承父类就有父类的全部方法
  public class Student extends Person{
      public Student() {
          //隐藏代码，调用父类的无参构造，调用父类的构造器super，只能放在子类的第一行
          super();
          System.out.println("Student无参构造");
      }
      private String name = "wyz";
      public void print(){
          System.out.println("Student");
      }
      public void text1(){
         print();
         this.print();
         super.print();
      }
      public void text(String name){
          System.out.println(name);
          System.out.println(this.name);
          System.out.println(super.name);
      }
  Aplication类：启动类
  public class Aplication {
      //一个项目只存一个main方法
      public static void main(String[] args) {
          Student student = new Student();
          //student.text("wang");
          //student.text1();
      }
  }
  super注意点：
        1.super调用父类的构造方法，必须在构造方法的第一个
        2.super必须只能出现在子类的方法或者构造方法中
        3.super和this不能同时调用构造方法
  super与this：
        代表的对象不同：
              this：本身调用者这个对象
              super：代表父类对象的应用
        前提：
              this：没有继承也可以使用
              super：只能在继承条件下才能使用
        构造方法：
              this()：默认调用本类的构造
              super()：调用父类的构造

方法的重写

  B类：父类
  public class B {
      public void test(){
          System.out.println("B的test()");
      }
  }
  A类：子类
  public class A extends B{
      //重写
      @Override
      public void test() {
          System.out.println("A的test()");
      }
  }
  Aplication类：启动类
  public class Aplication {
      //静态方法和非静态方法有很大的区别
      public static void main(String[] args) {
          //方法的调用只和定义的数据类型有关
          A a = new A();
          a.test();
          //父类的引用指向了子类
          //子类重写了父类的方法
          B b = new A();
          b.test();
        }
  }
  重写：需要有继承关系，子类重写父类的方法。
        1.方法名必须相等
        2.参数列表必须相同
        3.修饰符范围可以扩大，但是不能缩小 public>Protected>Default>private
        4.抛出的异常：范围可以被缩小，但不能扩大
        5.重写，子类的方法和父类必须一致，方法体不同！

6. 多态

  即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
  一个对象的实际类型是确定的，但可以指定对象的引用的类型有很多。
  多态存在的条件：
        有继承关系
        子类重写父类的方法
        父类引用指向子类对象
  注意：多态是方法的多态，属性没有多态性
  实例：Person  父类
  public class Person {
      public void run(){
          System.out.println("helloworld!!");
      }
  }
  Student：子类
  public class Student extends Person{
      @Override
      public void run() {
          System.out.println("son");
      }
  }
  Aplication：启动类
  public class Aplication {
      public static void main(String[] args) {
          //一个对象的实际类型是确定的
          //可以指向的引用类型就不确定了：父类的引用指向之类
          //Student能调用的方法都是自己或者继承父类的
          Student s1 = new Student();
          //Person 父类型，可以指向子类，但是不能调用子类独有的方法
          Person s2 = new Student();
          Object s3 = new Student();
          s2.run();
          s1.run();
          //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
          //子类重写父类的方法，执行子类的方法
      }
  }
  多态注意事项：
        1.多态是方法的多态，属性没有多态
        2.父类和子类，有联系，类型转换异常 classCastException！
        instanceof  类型转换（引用类型）

7. 抽象类

  abstract修饰符可以用来修饰方法，也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。
  抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
  抽象类，不能用new关键字来创建对象，他是用来让子类继承的。
  抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的。
  子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
  实例：
  package com.wyz.oop.demo05;
        //加入abstract变成抽象  类extends：单继承   接口可以多继承
        public abstract class Action {
            //约束，有人帮我们实现
            //abstract 抽象方法  只有方法名字  没有方法的实现
            public abstract void doSomething();
  }

8. 接口

  普通类：只有具体实现
  抽象类：具体实现和规范（抽象方法）都有
  接口：只有规范      
  接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能”的思想。
  接口的本质是契约，就像我们人间的法律，制定后大家就要遵守。
  OO的精髓，是对对象的的抽象，最能体现这一点的就是接口。
  声明类的关键字是class，声明接口的关键字是interface    
  实例：接口TimeService
  public interface TimeService {
      void timer();
  }  
  实例：接口UserService
  //interface：定义的关键字，接口都需要有实现类
  public interface UserService {
      //常量
      public int AGE = 99;
      //接口中的所有定义的方法其实都是抽象的public abstract
      //添加
      void add(String name);
      //修改
      void update(String name);
      //删除
      void delete(String name);
  }
  实例：类UserServiceImpl 
  public class UserServiceImpl implements UserService,TimeService{
      @Override
      public void add(String name) {
      }
      @Override
      public void update(String name) {
      }
      @Override
      public void delete(String name) {
      }
      @Override
      public void timer() {
      }
  }
  作用：
        1.约束
        2.定义一个方法，让不同的人实现
        3.接口中默认的方法：public abstract
        4.常量：public static final
        5.接口不能被实例化，因为接口中没有构造方法
        6.必须要重写接口中的方法

9. 内部类

  内部类就是在一个类的内部再定义一个类，
        1.成员内部类
        2.静态内部类
        3.局部内部类
        4.匿名内部类
  实例：成员内部类
  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);
          }
      }
  }
  实例：启动类
  public class Aplication {
      public static void main(String[] args) {
          Outer outer = new Outer();
          //通过外部类来实例化内部类
         Outer.Inner inner = outer.new Inner();
          inner.in();
          inner.getID();
      }
  }
  实例：静态内部类
  public class Outer {
      private int id = 10;
      public void out(){
          System.out.println("这是外部类的方法");
      }
      public static class Inner{
          public void in(){
              System.out.println("这是内部类的方法");
          }
      }
  }
  实例：局部内部类
  public class Outer {
      //局部内部类
      public void method(){
          class Inner(){
              public void in(){
              }
          }
      }
  }
  实例：匿名内部类
  public class Outer {
      public static void main(String[] args) {
          //匿名内部类
          new Apple().eat();
      }
  }
  class Apple{
      public void eat(){
          System.out.println("11");
      }
  }