面向对象（OOP）

面向对象（OOP）

初识面向对象

面向过程思想

• 步骤清晰简单
• 适合处理一些简单的问题

面向对象思想

• 物以类聚，分类的思维模式，思考问题首先解决问题需要哪些分类，然后对这些分类进行单独。最后，才对某个分类下的细节进行面向过程的思索。
• 适合处理复杂问题，以及多人协助。
• 从宏观，从整体上合理分析，要用面向对象的思想分析整个系统，仍然需要面向过程的思路去处理。

方法

• 静态方法和类一起加载，时间片较早，可以直接通过类名.静态方法名()调用

• 非静态方法，实例化后才存在，需要实例化new()方法，实例化后成具体的对象

• 实例化：对象类型 对象名=new 对象值

• 静态方法只能调用静态方法

• 使用new关键字会给具体的对象分配空间、初始化、调用类中的构造器（也叫构造方法）

• 值传递和引用传递

  public class Demo {
      public static void main(String[] args) {
          int a=1;
          System.out.println(a);
          Perosn perosn=new Perosn();
          System.out.println(perosn.name);
          Demo.change(perosn);
          System.out.println(perosn.name);
  //        Demo.change(a);
  //        System.out.println(a);//a!=10
          }
  //        public static void change(int a){
  //        a=10;//返回值为空
  //        }
      public static void change(Perosn perosn){
          perosn.name="yuan";
      }
      }
  class Perosn{//定义一个类，有一个属性name
      String name;
  }
  

类与对象

类与对象的关系

• 类是一种抽象数据类型，是对某一事物整体的描述
• 对象是抽象概念的具体实例

创建与初始化对象

• 创建对象（创建类）

• 实例化（创建测试类，new(实例化)对象）

• 对象名.属性=值

• //Person person=new Person();
  //对象的属性：person.属性名;
  //对象的方法：person.方法名;
  

构造器（也叫构造方法）

• 进行创建对象时需要调用

• 必须和类的名字相同

• 没有返回值类型，也不能写viod

• 可以初始化一些信息

• 生成构造器：快捷键Alt+ins

• 一旦定义了有参构造无参就必须显式定义

  package com.wly.Dome;
  
  public class Demo {
     String name;
     //构造器，实例化初始值
     //无参构造
      //使用new关键字，本质调用构造器
      public Demo(){
          this.name="yuan";
      }
      //有参构造
      public Demo(String name){
          this.name=name;
      }
  }
  

  package com.wly.Dome;
  
  public class DemoTest {
      public static void main(String[] args) {
  //        Demo demo=new Demo();
          Demo demo=new Demo("yuan");
          System.out.println(demo.name);//对象名.属性
      }
  }
  
  

创建对象内存分析

面向对象三大特性

封装

• 高内聚（内部数据操作细节自己完成），低耦合（仅暴露少量方法给外部使用）

• 禁止直接访问一个对象中数据的实际表示，应该通过接口来访问，这称为信息隐藏

• 主要对应属性，将属性私有化（private），别的类不可以直接访问

• public/protected/default/private

• 需要操作属性，类提供一些操作属性的方法（get/set方法）（获得/设置值）

• 通过封装制定一些规则，提高程序安全性，保护数据，提高可维护性

• 对象类

  package com.wly.Dome;
  
  public class Demo {
      private String name;
      private int age;
      public String getName() {
          return this.name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          if (age<120 && age>0){//制定规则
              this.age = age;
          }else{
              this.age=3;
          }
      }
  }
  

• 测试类

  package com.wly.Dome;
  
  public class DemoTest {
      public static void main(String[] args) {
          Demo demo=new Demo();
          demo.setName("nx");//通过set方法设置值
          demo.setAge(130);
          System.out.println("名字"+demo.getName());
          System.out.println("年龄"+demo.getAge());
      }
  }
  

继承（extend）

• 本质是对某一批类进行抽象，类与类之间的关系

• Java只有单继承，没有多继承（一个父类及多个子类）

• 子类可以继承父类的所有方法

• 私有的不可以被继承

object类

所有的类默认继承object方法

super

• 调用父类方法或属性：super.方法名/属性名

• 隐藏代码super();//调用父类的构造器必须在子类的第一行

• 必须只能出现在子类的方法或构造方法中

• super和this不能同时调用构造方法

  • this：本身调用者的这个类

  • this():本类的构造方法

  • super：代表父类对象的应用，只有在继承条件才能使用

  • super():父类的构造方法

方法重写

• 非静态方法

• 有继承关系

• 方法名相同

• 参数列表相同

• 父类的引用指向子类

• 修饰符：范围可以扩大但不能被缩小

• 抛出异常：范围可以被缩小，但不能被扩大

  重写原因

  父类的方法子类不一定需要

多态

定义

同一个方法可以根据发送对象的不同采用不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类或者有关系的类）

多态的存在条件

有继承关系

子类重写父类方法

父类引用指向子类

• 多态是方法的多态

• 父类可以转换为子类，类型转换异常ClassCastException

• 存在条件：继承关系，重写方法

• 不能重写：

  • static方法，属于类，不属于实例
  • final 常量
  • private 私有的

• public class Person {
      public void run(){
          System.out.println("zou");
      }
  }
  

• public class Man extends Person {
      public void run(){
          System.out.println("pao");
      }
      public void eat(){
          System.out.println("beef");
      }
  }
  

• public class DemoTest {
      public static void main(String[] args) {
          Man a=new Man();
          Person b=new Man();
          Object c=new Man();
  
          //主要看左边
          //子类可以调用自己和继承父类的方法
          //父类可以引用子类但是不能调用子类独有的方法
          a.run();
          b.run();//子类重写了父类方法，执行子类的方法
          ((Man) b).eat();//子类重写父类的方法执行子类
      }
  }
  

instanceof（类型转换）引用类型

比较转换

System.out.println(类型1 instanceof 类型2)//判断是否有继承关系，输出ture/false

父类引用指向子类

子类转换为父类，向上转型

父类转换为子类，向下转型，需要强制转换

static方法详解

• 可以直接调用

• 静态代码块只能调用一次

• 静态导入包（直接导入包中的某一方法）

• {
      {
          System.out.println("匿名代码块");
      }
      static {
          System.out.println("静态代码块");
      }
  
      public Person() {
          System.out.println("构造方法");
      }
  
      public static void main(String[] args) {
          System.out.println(new Person());
          System.out.println("==============");
          System.out.println(new Person());
      }
  }
  

抽象类和接口

抽象类

• abstract修饰符修饰，修饰方法交抽象方法，修饰类叫抽象类

• //abstract抽象类
  public abstract class DemoTest {
      //抽象方法，只有方法名没有方法具体实现
      public abstract void doSomething();
  }
  

• 子类继承抽象类，则必须实现抽象类的所有方法

• 不能new出来

接口

• 定义了一组规则，本质是契约
• interface定义接口
• 类实现接口必须实现接口的所有方法，关键字implement
• 接口可以多继承（接口之间用 ", "隔开）

内部类及oop实战

• 成员内部类

• package com.wly.Dome;
  
  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 static void main(String[] args) {
          //通过外部类实例化内部类
          Outer outer=new Outer();
          Outer.inner inner=outer.new inner();
          outer.out();
          inner.in();
          inner.getId();
      }
  }
  

• 静态内部类

  static修饰的内部类

• 局部内部类

  方法里的内部类

• 匿名内部类