Java基础（五）面对对象

一、面向对象

　　面向对象 ： 就是一种编程思想

1、类和对象

　　类是指描述一类事物，或者看成是一个分类，可以把类看作构造对象的模板。

　　对象是指具体的个体（也叫实例-instance）。创建对象使用 new，没对象就 new 一个对象。

1、设计类

语法：

 class 类名{
     成员变量  (字段)
     方法 （具体的一个功能行为）
 }

类规范书写：

①类名首字符大写;

②类名必须具有意义;

③必须写注释；

 public class Car {
     String name;  //字段
     Integer price;

     void run(){  //方法，具体行为
         System.out.println("run");
     }
 }

2、构造方法

　　创建对象本质上是调用类的构造方法。

 public class Car {
     String name;  //字段
     Integer price;

     void run(){  //方法，具体行为
         System.out.println("run");
     }

     //构造方法，无参构造方法
     public Car() {
     }
 }

特点：

1、每一个类中都至少有一个构造方法；如果没有看到（显示的），那么存在一个隐式的无参数的构造方法；如果一个类中有显示的构造方法，那么隐式的就不存在了。

2、构造方法的名字和类名一致（包括大小写完全一致）。

3、没有返回值类型，构造方法内部不需要返回任何的数据。

4、其他的和普通方法类型 ，可以有修饰（public）,可以有形参列表，可以有方法体。

5、在创建对象的同时给对象的字段赋值，有参数的构造方法的作用。

6、构造器总是伴随着new操作一起调用的。

 public class Car {
     String name;  //字段
     Integer price;

     void run(){  //方法，具体行为
         System.out.println("run");
     }

     //构造方法
     public Car() {
     }

     //有参构造方法
     public Car(String name, Integer price) {  //在创建对象的同时给对象的字段赋值
         this.name = name;
         this.price = price;
     }
 }

3、封装

　　在面向对象程式设计方法中，封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法（数据隐藏）。

在Java 中的体现

1 把类中的字段（实例域）私有化；

2 给每一个字段都提供一组getter， setter方法  (方法的规范写法)；

3 在测试类中尝试创建对象,并通过调用getter setter方法完成对字段的赋值和取值；

优点：

　　适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。减少耦合。类内部的结构可以自由修改。可以对成员变量进行更精确的控制。隐藏信息，实现细节。

 public class Student {
     private String name;  //私有化字段
     private Integer age;

     //getter和setter方法
     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Integer getAge() {
         return age;
     }

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

this介绍：

　　当setter方法，里面参数名称都一样的时候，就选择就近原则；使用this。

4、继承

1、具体实现

　　提高了代码的维护性和复用性，并且让代码更加简洁。

Java类中的继承的语法格式：

 class A{ }

 class B extends A{ }

　　A 是 B 的父类，B 是 A 的子类。子类中可以继承父类的东西。

 /**
  * 父类
  */
 public class Animal {

     public void move(){
         System.out.println("move");
     }

 }

　　子类，非私有字段和方法可以被继承到。构造方法不能被继承。

 /**
  * 子类
  */
 public class Cat extends Animal {

     @Override
     public void move() {
         super.move();  //super关键字：通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
     }
 }

　　Java中只能是单继承，即一个类只有一个父类；但支持多重继承（多层继承），即一个类可以有子类,子类还可以子类...  子子孙孙无穷无尽...

2、方法的重写（Override）

方法重写的要求：

1、子类和父类的方法签名（方法名+方法参数列表）一致。

2、子类的访问权限不能比父类更低。

3、最好加上@Override，来让编译器检查是否重写正确。

4、私有方法和 static 方法不能被重写。

5、子类的返回值类型可以和父类相同或者是父类返回类型的子类。

 /**
  * 子类
  */
 public class Cat extends Animal {
     @Override
     public void move() {
         System.out.println("move on");  //重写父类方法
     }

 }

5、接口

　　接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

声明语法：

interface 接口名{
 // 内部可以有哪些成员--参考类
字段  全部都是全局常量（public static final修饰）
方法  全部都是抽象方法（缺省修饰public abstract）
构造方法  没有！
}

接口名一般加个大写的 I 在前面。

 public interface IAnimal {

     void run();

     void eat();
 }

　　使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

注意：

1、必须全部覆写接口中的抽象方法。

2、否则实现类也抽象类。

3、一个类可以实现多个接口，但必须重写所有接口中的抽象方法。

 public class AnimalImpl implements IAnimal {
     @Override
     public void run() {
         System.out.println("run");
     }

     @Override
     public void eat() {
         System.out.println("eat");
     }
 }

6、多态

　　 多态是同一个行为具有多个不同表现形式或形态的能力。即同一个事件发生在不同的对象上会产生不同的结果。

多态的优点：

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

多态存在的三个必要条件

1、继承

2、重写

3、父类引用指向子类对象

 /**
  * 父类
  */
 public class Animal {
     public void eat() {
         System.out.println("吃东西");
     }
 }

 /**
  * 子类
  */
 class Cat extends Animal {
     public void eat() {
         System.out.println("猫吃鱼");
     }

     public void work() {
         System.out.println("猫抓老鼠");
     }
 }

 class Dog extends Animal {
     public void eat() {
         System.out.println("狗吃骨头");
     }
     public void work() {
         System.out.println("狗看家");
     }
 }

 class Person extends Animal {
     public void eat() {
         System.out.println("人吃东西");
     }
     public void work() {
         System.out.println("人努力工作");
     }
 }

测试多态：

 public class Test {
     public static void main(String[] args) {
         Animal a = new Cat();  // 向上转型
         a.eat();   // 调用的是 Cat 的 eat ：首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
         Cat c = (Cat)a;  // 向下转型，强制转换
         c.work();    // 调用的是 Cat 的 work

         Animal b = new Dog();
         b.eat();
         Dog d = (Dog)b;
         d.work();

         Animal person = new Person();
         person.eat();
         Person p = (Person)person;
         p.work();

         /* 输出：
         猫吃鱼
         猫抓老鼠
         狗吃骨头
         狗看家
         人吃东西
         人努力工作*/
     }
 }

多态的实现方式

1、重写

2、接口

3、抽象类和抽象方法