java面向对象

java的核心思想就是面向对象编程。（oop思想）

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

1. 初识面向对象

面向过程思想：

• 步骤清晰简单，第一步该干什么，第二步…
• 面向过程适合处理一些较为简单的问题。

面向对象思想：

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

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

2. 对象的创建分析

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

public class demo01 {
    public static void main(String[] args) {
        //new一个Person对象
        Person person = new Person();
        //赋值
        person.name = "leoeric";
        //调用类里面的方法
        person.method();
    }
}
//创建一个类
class Person{
    String name;
    public void method(){
        System.out.println("hello world");
    }
}

**一个标准的类应该包含有参构造和无参构造，及getter，setter方法,变量必须由private修饰。

class method{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public method() {
    }
    public method(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void demo(){
        System.out.println("...");
    }
}

3. 面向对象三大特征

封装

• 该露的露，该藏的藏

  • 我们程序设计要追求“高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅仅暴露少量的方法给外部类使用。

• 封装（数据的隐藏）

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

• 也就是属性私有，getter （往外拿值）/ setter（往里传值） ， private（私有话）

      private String name;
      private int age;
  	//get/set方法
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          this.age = age;
      }
  

  封装的意义：

  1. 提高程序的安全性，保护数据。

  2. 隐藏了数据的实现细节。

  3. 统一接口

  4. 系统可维护性提高。

     public int getAge() {
             return age;
         }
         public void setAge(int age) {
             if(age <= 120 || age > 0 ){
             	this.age = age;    
             }else{
                 System.out.println("数据不合法");
             } 
         }
     

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”，子类是父类的扩展。
• java中只有单继承，没有多继承！
• 类和类之间的关系。
• 继承父类的所有方法，可调用。
• 私有方法不能继承。
• object类是所有对象的父类。
• final修饰的类不能被继承。

//Teacher继承了Person，Teacher不能再直接继承父类。
class Teacher extends Person{
    
}
class Student extends Person{
    
}
class Person {
    
}

this.参数为当前方法的值。

super.参数为父类的值。

方法重写：–在非静态方法下

class Person {
    public void method(){
        System.out.println("hello person");
    }
}
class teacher extends Person{
    //写上override表示方法重写，可以改变子类调用的方法
    @Override
    public void method() {
        System.out.println("hello teacher");
    }
}

多态

• 动态编译：类型：可扩展性。

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

• 多态存在的条件。

  1. 有继承关系，
  2. 子类重写父类方法，
  3. 父类引用指向子类对象。

• 注意：多态是方法的多态，属性没有多态性。

  格式：

  父类 对象名 = new 子类；

  调用父类方法，或者重写后的子类方法。调用的方法父类必须有，不能调用子类独有的方法，否则要强制转换为子类。——编译看左，运行看右

  public class demo01 {
      public static void main(String[] args) {
         
          Person teacher = new Teacher(); 
      }
  }
  class Teacher extends Person{
      @Override
      public void method() {
          super.method();
      }
  }
  class Person {
      public void method(){
  
      }
  }
  

  注意：

  1. 多态是方法的多态，属性没有多态。
  2. 父类和子类，有联系 类型转换异常！ClassCastExption!
  3. 多态存在的条件：方法需要重写，继承关系，父类引用子类对象！

4. 抽象类和接口

抽象类

在类前写abstract就变成抽象类，在方法前写就是抽象方法。

抽象类不能new。

抽象类可以写普通方法，但写了抽象方法的类必须是抽象类。

在方法前写，子类必须重写方法。

接口

• 普通类：只有具体实现。

• 抽象类：具体实现和规范（抽象方法）都有。

• 接口：只有规范！

• 接口就是规范，定义的是一组规则。

• 接口的本质是契约，制定后都得遵守。

• oo的精髓，是对对象的抽象，最能体现这一点的就是接口。

• 接口用interface定义

• 接口都有实现类。

• 实现类必须重写接口中的方法。

• 一个类可以实现多个接口。

//实现，
class Person implements demo{
    @Override
    public void demo01() {
    }
}
//定义接口
interface demo{
    void demo01();
}