华清远见重庆中心-java面向对象阶段技术总结

目录

Java面向对象编程

1. 面向对象编程概述

类、对象、方法

类Class

对象（Object）

类和对象的关系

面向对象的三大特性

封装

继承

多态

---

Java面向对象编程

1. 面向对象编程概述

        面向对象编程（Object Oriented Programming） 简称OOP，是当主流的编程思想。

        是创建解决问题的对象，赋予对象对应的行为和特征，让这些对象互相配合(调用对象的方法)完成。 这种思想致力于将计算机中的世界，描述的和现实中一致的思想，把所有事情交给相应的对象完成，侧重于如何创建解决问题的对象。

2.类、对象、方法

类Class

具有相同属性和行为的对象的集合，称为"一类"。可以理解为模板。 属性：描述对象的特征，在程序中，通过定义变量的形式表现属性。 行为(方法）：描述对象的动作，在程序中，通过定义方法的形式表现行为。 在程序中，通过定义一个class来定义一个类。在类中定义变量描述属性，定义方法描述行为。

定义类

[修饰符] class [类名]{         //属性(变量)         //行为(方法)

           [修饰符] [返回值类型] [方法名]（ [参数]或[空] ）{ }

}

 /*
 *定义一个书（Book）类，含有：
 *属性：编号(id)，书名(title)，作者(author),...；
 *行为（方法）：添加(addBook)，删除(deleteBook),...；
 **/
 public class Book{
     //定义书的属性
     int id;//编号
     String title;//书名
     String author;//作者

     //定义方法
     public void addBook(){//定义添加书籍的方法（行为）
         system.out.println("添加成功");
     }
     public String deleteBook(int id){//定义删除书籍的方法（根据id删除）
         system.out.println("删除成功");
     }
     ...
 }

对象（Object）

对象是类的一个实例，是类的具体表现。

创建对象

类名 对象名 = new 构造方法([参数])； 创建的对象，通过"."操作符访问类中的非私有属性和方法。

 /*
* 创建管理类(程序入口)，该类可以创建书类的对象
* */
 public class Manage{
     public static void main(String args[]){
         //创建书类的对象book1
         Book book1 = new Book();
         //给对象的属性赋值
         book1.id = 1;
         book1.title = "道德经";
         //通过对象调用Book类里的方法
         book1.addBook();
         book1.deleteBook(1);
     }
 }

类和对象的关系

对象是类的具体表现，类是对象的集合(模板)。 如包饺子的模具就是一个类，每次用这个模具包出来的饺子都是一个一个对象。 先定义类，才能通过该类创建对象。

3.面向对象的三大特性

封装

        使用private关键字对属性进行修饰。再对外提供一组公开的get/set方法用于对该属性读取或赋值。可以防止除自身类之外的地方对该属性就行访问，这样做可以保护关键属性，隐藏类内部的实现细节。

步骤

• 先创建一个类，编写成员变量，给成员变量添加private修饰符

public class Book {
    private int id;
    private String title;
    private String author;
}

• 单击右键选择Generate--->Getters and Setters--->选择要封装的属性

  或使用快捷键Alt+Insert(或Fn+Alt+Insert)--->Getters and Setters--->选择要封装的属性

• 封装成功：

  public class Book {
      private int id;
      private String title;
      private String author;
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  
      public String getTitle() {
          return title;
      }
  
      public void setTitle(String title) {
          this.title = title;
      }
  
      public String getAuthor() {
          return author;
      }
  
      public void setAuthor(String author) {
          this.author = author;
      }

  }

• setXxx()用于给私有的成员变量赋值。

• getXxx()用于读取私有的成员变量。

• 封装后，无法通过“.”访问属性，只能通过get/set方法。

继承

类A可以通过extends关键字继承类B。

语法：class 类A extends 类B{}

//父类A
public class A{
}

//子类B继承父类A
public class B extends A{
}

类A称为子类、派生类、衍生类、subClass 类B称为父类、根类、超类、superClass 继承后，子类可以访问父类中非私有(没有被private修饰的内容)的属性和方法。 不同的子类中如果有相同的代码，都可以把它们提出来保存到父类中，从而减少子类中的代码冗余。

特点

• 如果多个类之中有相同或类似的代码，可以将这些代码提取出来定义在一个公共的类中，这个类就是父类。再让那些类就继承这个父类，那些类就是子类，这样就能减少子类中的重复代码。

• 子类对象可以直接访问父类中非私有(不用private修饰)的属性和方法。

• 子类可以对父类中的方法进行扩展或覆盖，这称为方法重写。重写后，子类对象再调用该方法时，执行的是重写后的内容。

• Java中是单继承。一个子类只能extends一个父类，一个父类可以有很多个子类。

• Java中可以多重继承。类A可以继承类B，类B可以继承类C，这时类A既是类B的子类，也可以称为类C的子类，可以访问类B与类C中非私有的成员。

• 任何类都是Object类的子类。

• 在创建子类对象时，会先执行父类中相应的构造方法

方法重写（override）

当子类继承父类后，可以对父类中非私有的方法进行扩展或覆盖，这个过程称为方法重写。

//父类A
 public class A {
    // 父类方法father()
    public void father(){
        System.out.println("父类方法");
    }
}
 //子类
 public class B extends A {
    //重写方法father()
    @Override
    public void father() {
        System.out.println("子类重写方法");
    }

    public static void main(String[] args) {
        A a=new A();   //新建父类对象
        B b=new B();   //新建子类对象
        A b1=new B();
        //新建对象new B()只能创建只能比类型A小

        a.father();
        b.father();
        b1.father();


    }
}

//输出：
    父类方法
    子类重写方法
    子类重写方法

方法重写要求

• 方法名、参数列表、返回值必须和父类一致。

• 访问权限不能比父类更严格(访问修饰符的范围要么一致要么更大)。

• 不能抛出比父类更大的异常。

方法重载(overload)

• 在一个类中，如果多个方法的方法名相同，参数列表不同时，这些方法称为重载的方法。

• 重载用于在一个类中，某个方法在不同的条件下，执行不同的内容。

public class Main {
    public static void main(String[] args) {
        Main m=new Main();
        m.father();//无参无返回值
        m.father(10);
        System.out.println(m.father("重载"));
    }

    public void father(){
        System.out.println("无参无返回值");
    }
    //重载
    public void father(int i){
        System.out.println("有参为int类型："+i+",无返回值");
    }
    //重载
    public  String father(String str){
        return "有参为String类型："+str+",有返回值为String类型";

    }
}
//输出：
    无参无返回值
    有参为int类型：10,无返回值
    有参为String类型：重载,有返回值为String类型

方法重载要求

• 方法名相同。

• 参数列表(参数类型和数量)不同。

• 与返回值无关。

多态

概念

• 多态就是子类的对象指向父类的引用(子类对象使用父类变量接收，即向上转型)。

• 父类 变量 = new 子类();

多态的应用

• 当某个方法的参数为父类变量时，可以传递一个子类对象。这样就能在传递不同子类对象时，执行不同的方法。如要调用动物发出叫声的方法，参数为猫，输出喵喵叫，参数为狗，输出汪汪叫。不用多态，需要写多个重载的方法，参数为猫或狗的具体类型。使用多态，只需一个方法，参数为动物类型，动物类中定义一个叫的方法，让猫和狗继承这个动物类，重写叫的方法。这时调用动物发出叫声的方法时，就会根据实际的参数，表示不同的结果。

多态的实现条件

• 在继承关系中。

• 子类需要重写父类中的方法。

• 父类的引用指向子类的对象(向上转型)。