面向对象总结

面向对象程序设计(Object-oriented Programming,OOP)

• 首先基本概念的了解
  • 对象：对象是类的实例。有行为和属性，如：人类是一个对象：属性有：姓名，性别，年龄…行为有：吃饭，睡觉等。
  • 类：类是一个模板，描述一类对象的行为和状态。
  • 方法：方法就是行为，一个类可以有多个方法。
  • 实例变量:每一个对象都有独特的实例变量，对象的状态由实例变量的值决定。

面向对象的三大特征

封装

封装指一种抽象性函式接口实现细节部分包装(private),隐藏起来，然后给外部提供公共的方法

• 如:实体类Person

public class Person {
    private int age;   //使用关键字对属性进行封装
    private String userName;
    private String gender;

    public int getAge() {   //提供公共的setting/getting方法
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

• 封装的优势
  1. 减少耦合
  2. 对成员进行更精确的控制
  3. 隐藏信息，实现细节

继承(is-a)

多个类中存在相同的行为和属性，将这些内容抽取到一个单独的类中(被称为基类，父类或超类),那么多个类(被称为基类，继承类或子类)无需再定义这些属性和行为，只要继承(extends)父类即可。

• 如

  /**
   * @program: Bridge Pattern
   * @description:
   * @author: Mr.Yan
   * @create: 2019-03-17 12:05
   **/
  
  public class Person {
      protected int age;
      protected String userName;
      protected String gender;
      private int height;
      public void sleep(){
  
      }
  
      public Person() {
      }
  
      public Person(int age, String userName, String gender, int height) {
          this.age = age;
          this.userName = userName;
          this.gender = gender;
          this.height = height;
      }
  
    //setting/getting方法此处省略。
  
      @Override
      public String toString() {
          return "Person{" +
                  "age=" + age +
                  ", userName='" + userName + '\'' +
                  ", gender='" + gender + '\'' +
                  ", height=" + height +
                  '}';
      }
  }
  
  

  /**
   * @program: Bridge Pattern
   * @description:
   * @author: Mr.Yan
   * @create: 2019-03-17 15:26
   **/
  
  public class Student extends Person {
      /**
       * 子类可以有自己特有的方法
       */
      public void study() {
          System.out.println("学生学习");
      }
  
      @Override
      public String toString() {  
          //通过快捷键生成的tostring（）我们已经可以看到,子类已经默认重写了父类的非私有属性
          return "Student{" +
                  "age=" + age +
                  ", userName='" + userName + '\'' +
                  ", gender='" + gender + '\'' +
                  '}';
      }
  }
  
  

  /**
   * @program: Bridge Pattern
   * @description:测试类
   * @author: Mr.Yan
   * @create: 2019-03-17 15:46
   **/
  
  public class Test {
      public static void main(String[] args) {
          Person p = new Person(); //首先进行父类测试
          p.setAge(40);
          p.setGender("男");
          p.setHeight(180);
  //        p.heigth = 180;   这两种方法都可以进行赋值
          p.setUserName("张三");
          System.out.println(p);
          Student s = new Student();
  //        s.heigth = 175;   //我们发现子类的heigth不可以直接赋值，因为父类对他进行了私有化，但是提供了公共的setting/getting方法
          s.setHeight(175);
          s.setAge(20);
          s.setUserName("李四");
          s.setGender("男");
          System.out.println(s);
      }
  }
  
  

  控制台输出

  

• 继承的简单小结
  1. java不支持多继承(person extend Student,Teacher)，但是支持多重继承(A extend B C extend B)
  2. 子类拥有父类非private的属性，方法。
  3. 子类可以拥有自己的属性和行为。
  4. 提高了类之间的耦合性(继承的一大缺点)。
  5. java中类默认继承Object类。

多态

• 多态面向对象中最重要的概念,有两种体现方式。

  1. 重载(overload)

     • 何为重载：我们称在一个类中有两个或两个以上的方法具有相同的方法名,但是参数列表不同，我们称之为重载。

     • 示例

       public class Count {
           public static void main(String[] args) {
               /**
                * add()
                * add2()
                * 两者方法名相同，参数列表不同称之为重载
                */
              Count.add(10,20);
              Count.add2(10,20,30);
           }
           public static void add(int a,int b) {
               System.out.println("add:"+a+b);
           }
           public static void add2(int a,int b,int c) {
               System.out.println("add2:"+a+b+c);
           }
       }
       
       

  2. 重写(overwrite)

     • 何为重写：重写发生在父子类之中，当子类继承父类，与父类中的方法同名，同参，我们称之为重写

  3. 对象的多态性：父类引用指向子类对象实体(父类 父 = new 子类())

  抽象类

  • 抽象是隐藏实现细节并向用户显示供能的过程。

  • 抽象可以让你专注于对象做什么（实现的功能）,而不是他如何做。

  • 抽象类实现接口时，可以选择性的重写接口。

  • 实现抽象的方法.

  abstract class absPerson{   //用abstract修饰的类称为抽象类
      abstract void sleep();  //抽象方法没有实现,抽象类中的方法默认是抽象的
      void run() {			//非抽象方法要有实现（1.8以后支持）
          
      }
  }
  

  接口

  • 接口是一种实现抽象的机制，接口中只能有抽象方法（默认抽象）

  • 接口中可以定义静态常量和抽象方法。

  • 用于实现耦合。

  • 接口时隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

  • 接口中的方法都是公共的。

    public interface DrawAPI {
        static int a = 10;//接口中的静态常量
        /**
         *
         * @param radius：半径
         * @param x
         * @param y
         */
        public abstract void drawCircle(int radius,int x,int y);
        //接口中的方法默认public abstract
    }
    
    

  抽象类和接口的异同

  1. 抽象类中的方法可以有方法体，接口中没有（1.8以后有）
  2. 抽象类中的成员变量可以是各种类型的，接口中成员变量只能是public static final类型的（默认）
  3. 接口中不能有静态代码块以及静态方法（1.8以后可以写静态方法），抽象类可以有静态代码块和静态方法。
  4. 类只能继承一个抽象类，却可以实现多个接口。
  5. 两者都不能实例化。（new)

  类与类，接口与接口，类与接口的关系

  

static关键字

• static主要用来内存管理，用于变量，代码块等，static属于类，而不是类的实例
• 静态变量
  • 静态变量可以用于引用所有对象的公共属性。
  • 使程序存储器高效(节省内存)。
• 静态方法
  • 静态方法属于类，而不属于类的对象。
  • 可以直接调用静态方法，而无需创建类的实例。
  • 静态方法可以直接访问静态数据成员，并可以更改静态数据成员的值
• 静态代码块
  • 用于初始化静态数据成员。
  • 在类加载时mian方法执行前执行。

java聚合

• 如何一个类有一个类实体的引用(类中的类)则称之为聚合（has-a）
• 优势：代码可重用性。
• 以下以省，市为例。

/**
 * @program: Bridge Pattern
 * @description:地址类
 * @author: Mr.Yan
 * @create: 2019-03-17 18:48
 **/

public class Address {
    public String city; //市
    public String province;//省

    public Address(String city, String province) {
        this.city = city;
        this.province = province;
    }
}

public class Emp {
    private int id;
    private String name;
    private Address address;

    public Emp(int id, String name, Address address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
    void display() {
        System.out.println(id+""+name);
        System.out.println(address.city+address.province);
    }

    public static void main(String[] args) {
        Address address1 = new Address("西安","陕西");
        Address address2 = new Address("成都","四川");

        Emp e = new Emp(111,"wang",address1);
        Emp e2 = new Emp(222,"li",address2);
        e.display();
        e2.display();
    }
}

个人博客更多资料