java基础知识-面向对象的三个特性

这一节，我们主要讲一下java面向对象的3个特性，即封装，继承，多态，

java封装

• java的封装主要是将对象的实现细节隐藏起来，然后通过一些公共的方法来向外暴露出该对象的功能。适当的封装可以让代码更容易理解和维护，也加强了程序的安全性。

在之前，我们定义的变量和方法都是使用public修饰符来进行修饰，为了实现封装，防止该类的代码和数据被其它类随便访问，我们使用了一个新的修饰符private,private是一个权限修饰符，代表最小的权限，经过private修饰后的成员变量和成员方法只有在本类中才能访问，同时，我们提供了对应的getXXX方法和setXXX方法，来对成员变量访问。

基本格式

public class Person{
   public class Person {
     //定义两个私有成员变量
     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;
    }
}
}

经过封装以后，我们就不能通过对象.属性来对属性进行修改了，只能通过set方法和get方法来进行赋值或者获取。其中的this关键字用来表示当前对象本身或者当前类的一个实例，通过this关键字我们可以对整个类的成员变量和方法进行访问。在这里，也是为了解决成员 变量和局部变量之间发生的同名冲突。

这里为了方便，我用的是junit单元测试，不了解的可以在main函数里执行就可。当然，比较建议给一个有参构造函数，当一个对象被创建的时候就可以用来初始化该对象，给对象的成员变量赋初始值。

java继承

• 继承是面向对象实现软件复用的重要手段，当子类继承父类后，子类就可以获得父类的特征和行为。

缺点：

1.继承是一种强耦合的关系，父类变子类也必须跟着变

2.继承破坏了封装，对于父类而言，它的实现细节对子类来说都是透明的。

继承的基本格式

class  父类{

}
class  子类  extends  父类{

}

public class Person {
    public String name;
    public  int age;
    public void eat(){
        System.out.println("吃东西");
    }
    public  void  sleep(){
        System.out.println("睡觉");
    }
}

public class Student extends Person{
    public void playGame(){
        System.out.println("打游戏");
    }
}

继承的目的就是把一些共有的代码抽取出来，放到一个公共的类中，就可以实现代码的复用，接下来我们介绍一下子类继承父类之后的一些特点。

1.如果子类和父类中出现重名的成员变量，这个时候会优先访问子类的成员变量。如果想访问父类的成员变量，这个时候就需要使用super关键字，类似于之前的this.

super.父类成员变量

2.如果子类和父类中出现重名(返回值类型，方法名和参数列表都相同)的方法，这个时候就叫做方法的重写，这个和方法的重载不同，重载是要方法的方法名相同，参数列表不同。通过方法的重写我们可以根据子类的需要重新实现父类方法，从而进行方法的扩展。

3.当成员方法不重名时，在对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

4.子类是无法继承父类的构造方法的，因为构造方法是要求和类名相同的。构造方法的作用是初始化成员变量的，所以子类的初始化过程中，必须先执行父类的初始化方法，

public class Person {
   public Person(){
      System.out.print("默认调用父类的构造方法");
   }
}

public class Student extends Person{
   
}

@Test
public void test3(){
     Student stu = new Student(); 
}

在子类中的构造方法中默认有一个super(),表示调用父类的构造方法。

5.java中的继承属于单继承，就是一个子类只能继承一个父类，但是支持多重继承，就是可以B类继承A类，然后C类继承B类这样。

注意：子类要想访问父类的成员变量，必须要求父类的成员变量是私有的

java的多态

• 多态就是对于同一个行为具有多个不同表现形式或者形态的能力。

例如，在我面前有一杯水，我不知道它的温度，我摸水杯的动作，对于不同温度的水，就会得到不同的结果，这个就是多态。

前提条件

1. 继承或者实现接口

2. 方法的重写

3. 父类引用指向子类对象(向上转型)

   父类类型  变量名  =  new   子类对象；
   变量名.方法名();
   

   这里的父类类型就是前提条件中要继承的父类或者实现的接口

当我们使用多态方法来调用方法时，首先检查父类中是否存在该方法，如果没有则编译错误，如果存在，则执行子类重写后的方法。

public class Animal {
     public void eat(){};
}

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

public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

 @Test
    public  void  test3(){
        Animal dog = new Dog();
        dog.eat();
        Animal  cat = new Cat();
        cat.eat();
    }

就像上面的呢样，调用的是eat方法，但是最后却得出不同的结果。

我们发现，这与我们之前实例化对象不同，我们之前是 类名 变量名 = new 类名()这样的方式，而现在却不一样了，上面的两个实例化对象的代码就是向上转型，将子类的引用赋给父类对象，

多态的好处：

当把不同的子类对象都当做父类类型来看，可以屏蔽不同子类对象之间的实现差异，从而写出通用的代码达到通用编程，以适应需求的不断变化。

举个例子，假如我现在有很多种类的动物，要喂它们吃东西，如果不用向上转型，那么我的代码如下

public static void main(String[] args){
     method(new Cat());
     method(new Dog());
     .....
}
public static void method(Dog a){
      a.eat();
}
public static void method(Dog a){
      a.eat();
}
.........

假如我现在有一万个动物，那么下面的方法我要写一万个，这个时候使用多态就很方便

public  static void method(Animal a){
       a.eat();
}

这个时候即使它有一万个，我也只需要写一个就可以了，通过向上转型。多态的弊端就在于子类特有的方法是无法调用的。