Java面向对象

[huangchucai]

Java面向对象

面向对象编程主要是通过有以下几个知识点

1. 对象和类
2. 封装和继承
3. 抽象类
4. 接口
5. 多态

封装和继承

1. 封装

• 定义：隐藏内部细节，仅对外公开接口，控制程序中的属性的读写
• 目的：把代码分成两个部分“实现”和“接口”，用户和接口进行交互，保持稳定，而内部实现可以不暴露给用户，可以方便重构。

public class Encapsulation {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public static void main(String[] args) {
        Encapsulation test = new Encapsulation();
        test.setName("hcc");
        System.out.println(test.getName());
    }
}

2. 继承

• 定义： 实现代码的复用，它可以创建分等级层次的类。

• 介绍：一般写代码的时候很难直接想到继承的关系，但是当写到两个类具有相同的特征（属性）和行为（方法）的时候，可以把他们相同的部分抽到一个类中作为父类，其他的两个类继承这个父类。继承后的子类就自动拥有父类的属性和方法

• 注意：

  1. 父类的私有属性和构造方法不能被继承。（private）
  2. 子类可以有自己的方法和属性，实现功能的拓展
  3. 子类也可以复写父类的方法（方法的重写override）
  4. 使用protected修饰符，可以给子类访问，隐藏给其他类进行访问
  5. Java 只支持单继承，即只能有一个父类
  6. 通过super直接访问父类的属性和方法，this指向自己的实例引用

  // 父类
  public class Animal {
      protected String species;
      protected String food;
      protected int age;
  
      public Animal(String species, int age, String food) {
          this.species = species;
          this.age = age;
          this.food = food;
      }
      public static void parentsName() {
          System.out.println("动物");
      }
      public void eat() {
          System.out.println("吃:" + this.food);
      }
  
  }
  
  // 子类
  public class Cat extends Animal {
      private String name;
      public Cat(String species, int age, String food) {
          super(species, age, food);
          super.parentsName();
      }
      public void setName(String name){
          this.name = name;
      }
  
      public String getName() {
          return name;
      }
  }
  
  // 使用
  public class Main {
      public static void  main(String[] args) {
          Cat cat = new Cat("猫科", 1, "鱼");
          cat.eat();
          cat.setName("薄荷");
          System.out.println(cat.getName());
      }
  }

3. 重写(override)

• 定义：子类根据自己的需求，对父类的方法进行重写编写，重写后，子类无法直接访问父类被覆盖的方法，必须通过super关键词访问（super.方法（）），但是父类的构造函数不能被重写

• 规则：

  1. 方法名相同
  2. 参数列表相同
  3. 返回值相同或者是其子类
  4. 访问权限要低于父类

• 重写和重载的区别（over）

  1. 重载主要是同一个类的同名方法中，而重写发生在子类和父类的同名方法

     比较项	位置	方法名	参数列表	返回值	访问权限
     方法重载	同一个类	相同	不相同	没有要求	没有要求
     方法重写	子类和父类	相同	相同	相同或其子类	比父类权限低

抽象类（abstract）

• 定义： 对类的一个抽象，定义类比较通用的概念，用于拓展类

• 规则：

  1. 不能被实例化，只能被继承使用
  2. 抽象类中的抽象方法没有方法体，如果继承了抽象类，必须实现抽象方法（override）或者继续抽象
  3. static方法不能被声明为抽象方法，只能用public、protected来修饰抽象方法（因为抽象方法没有方法体，是用来被继承的，所以不能使用private修饰，static可以通过类名直接访问，但是由于没有方法体，所以也没有意义）

  // 抽象类
  public abstract class Base {
      public abstract String method1();
      public abstract void method2();
  }
  
  // 子类一(实现了抽象方法)
  public class sub1 extends Base{
      @Override
      public String method1() {
          return "hcc";
      }
  
      @Override
      public void method2() {
          System.out.println("实现抽象类的重写");
      }
      public void selfMethods() {
          System.out.println("自己的方法");
      }
  }
  // 子类二(继续是抽象类)
  public abstract class sub2 extends Base {
      public abstract void sub2();
  }

接口（interface）

• 定义： 一系列抽象方法的集合（但是不需要使用abstract, 隐藏的public abstract），接口不是类，不能被实例化对象，只能通过类来实现（implements）它

• 规则：

  1. 没有构造方法，不能被实例化，实现类必须实现接口的所有方法
  2. 所有的方法都是抽象方法，所有的属性都是常量（static final）
  3. 一个类可以实现多个接口

  // interface
  public interface Car {
      void run();
      String seat();
  }
  // 实现
  public class Benz implements Car{
      @Override
      public void run() {
          System.out.println("速度很快");
      }
  
      @Override
      public String seat() {
          return "4人座位、2人座位";
      }
  }

接口和抽象类的区别

区别：

• 接口更加倾向于类的功能，更加具体。而抽象类表示类的一个抽象，用于继承被拓展
• 接口不是类，而抽象类还属于类的部分

举例：就像人这个物种，可以说它是一个动物，就是是一个大的抽象（抽象类），但是它具有运动，捕猎，学习的具体功能（接口）。再比如车，某汽车公司seo画饼说我司轿车是高端奢华型，面向上流社会，这是抽象类 ，汽车设计师说那就四驱，发动机这样，内饰这样，这是接口

多态

定义

多态：表示一个类型（父类或者接口或抽象类）的变量的方法的具体实现行为由变量指向的具体对象确定。

形成条件

1. 要有继承
2. 要有重写
3. 父类引用指向子类对象

实现方式

1. 继承和接口
2. 父类和接口类型的变量赋值子类对象（父类引用指向子类对象）
3. 调用被override的方法

1. 继承和接口实现多态

场景：现在要读取一个新闻文件，可以从文本，网络，标准输入，语言识别等

// 抽象类 NewsReader 只是定义读取，不管怎么读取
public abstract class NewsReader {
    public abstract News readNews(String path);  // 具有这个功能，但是具体的功能实现，在子类中确定!
}

// 从网络中读取 返回News的实例
public class UrlNewsReader extends NewsReader {
    @Override
    public News readNews(String path) {
        return new News("从网络中读取", "test");
    }
}

// 从文件中入读
public class FileNewsReader extends NewsReader {
    @Override
    public News readNews(String path) {
        return new News("从文件中读取", "test");
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        News news = new News("第一条新闻", "hhhhhhhhhhhhhhh");
        viewNews(news);
		News newsFromFile = read(new FileNewsReader(), "simple/res.txt");
        News newsFromUrl = read(new UrlNewsReader(), "simple/res.txt");
    }

    private static News read(NewsReader reader, String path) {
        return reader.readNews("res/output.txt");
    }
}

我们从上面的例子中看实际的形成条件

1. 要有继承： 我们从网络中读取UrlNewsReader和文件中读取 FileNewsReader都继承了读取
2. 重写： 子类都全部重写了readNews方法，并调用了重写的方法
3. 父类引用指向子类对象： 在Main.java中我们的read统一处理了文件的读取，接受的是父类的引用，但是传递的确实子类的对象，所以返回了不同的News，有了不同的行为

多态的好处

1. 可以对于同一个行为有不同的处理。
2. 对于大量的重复操作，我们可有封装成一个函数，接受父类参数进行统一处理
3. 可以像子类提供统一的接口，让子类进行拓展和完善