Java基础回顾 | Java面向对象的四大特性

非常长的一段时间没有完善自己的博客了，一直觉得总有一些事情没做完，现在重新打开自己的博客，来完善之前一直想完成的事情。下面是本篇文章的目录：

废话不多说，我们直接进入主题

封装

什么是封装

封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

例子加深理解：收拾行李时，太多的衣服一个人不方便拿、也拿不了那么多，此时会想拿一个行李箱把衣服都装起来、隐藏在行李箱里面，我直接拿行李箱就可以随时外出了。

• 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部 类定义的代码随机访问。
• 要访问该类的代码和数据，必须通过严格的接口控制。
• 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
• 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

理解到位我们进行代码更深刻的理解，代码如下：

Person类(利用private修饰符进行访问限制，可以参考之前的文章Java修饰符)

public class Person {
    private String name;
    private int age;
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

提供公共方法给外部进行访问

public class Person{
private String name;
private int age;
​
public int getAge(){
  return age;
}
​
public String getName(){
  return name;
}
​
public void setAge(int age){
  this.age = age;
 }
​
public void setName(String name){
  this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

实例运用

/* F文件名 : RunEncap.java */
public class RunEncap{
   public static void main(String args[]){
  Person person = new Person();
  person.setName("chocozhao");
  person.setAge(20);

  System.out.print("Name : " + person.getName()+ 
 " Age : "+ person.getAge());
 }
}

继承

什么是继承

• 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
• 父类更通用，子类更具体。
• 子类会具有父类的一般特性也会具有自身的特性。

理解例子：一对父子，老爸具有一家价值一个亿的公司，需要儿子去接手老爸的产业，儿子的性格、行为、处事方式和老爸非常类似，儿子接管老爸的公司，在老爸的产业基础上为公司深造，儿子做得更加具体的独特风格，出色。

继承格式

代码如下(在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的)

class 父类 {
    父类实现代码
}

class 子类 extends 父类 {
    在父类的基础上子类实现的代码
}

继承类型

一图让你深刻理解继承类型(特别要注意多继承和多重基础的区别哦) 

继承特性

1. 子类拥有父类非private的属性，方法。
2. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。
4. Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
5. 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承的关键字

extends关键字

extends：类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类

public class Animal { 
private String name;   
private int id; 
public Animal(String myName, String myid) { 
//初始化属性值
} 
public void eat() {  //吃东西方法的具体实现  } 
public void sleep() { //睡觉方法的具体实现  } 
} 

public class Penguin  extends  Animal{ 
}

implements关键字

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

public interface A {
    public void eat();
    public void sleep();
}

public interface B {
    public void show();
}

public class C implements A,B {

}

super和this关键字

super：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this：指向自己的引用、当前类引用。

实例：

class Animal {
  void eat() {
     System.out.println("animal : eat");
  }
}

class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
     this.eat();   // this 调用自己的方法
     super.eat();  // super 调用父类方法
  }
}

public class Test {
  public static void main(String[] args) {
     Animal a = new Animal();
     a.eat();
     Dog d = new Dog();
     d.eatTest();
  }
}

运行结果

animal : eat

dog : eat

animal : eat

抽象

什么是抽象

抽象类：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

直接上代码

Animal2类(抽象类，没有具体实现)

abstract class Animal2 {
    private String name;
    private int age;

    public Animal2() {
    }
    public Animal2(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public abstract void eat();//抽象方法
}

Dog2类(继承了Animal2，具体实现了eat方法)

注意哦！这里是Dog2(实现类)继承Aniaml2（抽象类）实现所需要的功能的哦！

class Dog2 extends Animal2 {
     public Dog2() {
     }

     public Dog2(String name, int age) {
         super(name, age);
     }

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

Main程序入口实现运行

public class ChouXiangTest {
 public static void main(String[] args) {
    Animal2 a = new Dog2();
    a.setName("Tom");
    a.setAge(9);
    System.out.println(a.getName() + "   " + a.getAge());
    a.eat();
    System.out.println("-------");
    Animal2 a2 = new Dog2("Sala", 90);
    System.out.println(a2.getName() + "  " + a2.getAge());
    a2.eat();
 }
}

运行结果

接口

说到抽象，下面插播一则"广告"——接口，方便各位理解，避免接口和抽象之间产生混淆。

什么是接口

• 在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
• 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口与类的区别 - 接口不能用于实例化对象。 - 接口没有构造方法。 - 接口中所有的方法必须是抽象方法。 - 接口不能包含成员变量，除了 static 和 final 变量。 - 接口不是被类继承了，而是要被类实现。 - 接口支持多继承。

接口与抽象类的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口实例

/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

接口实现

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{

   public void eat(){
     System.out.println("Mammal eats");
   }

   public void travel(){
     System.out.println("Mammal travels");
   } 

   public int noOfLegs(){
     return 0;
   }

   public static void main(String args[]){
     MammalInt m = new MammalInt();
     m.eat();
     m.travel();
   }
}

运行结果

Mammal eats

Mammal travels

接口继承

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

接口多继承

public interface Hockey extends Sports, Event

多态

什么是多态

• 同一个行为具有多个不同表现形式或形态的能力
• 同一种行为发生在不同对象身上会发生不同的结果

理解例子：

现实中，比如我们按下 F1 键这个动作：

• 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
• 如果当前在 Word 下弹出的就是 Word 帮助；
• 在 Windows 下弹出的就是 Windows 帮助和支持

多态的优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态的前提条件

• 继承
• 重写
• 父类引用指向子类对象

老规矩直接上代码：

public class Test {
     public static void main(String[] args) {
         show(new Cat());  // 以 Cat 对象调用 show 方法
         show(new Dog());  // 以 Dog 对象调用 show 方法

          Animal a = new Cat();  // 向上转型  
          a.eat();               // 调用的是 Cat 的 eat
          Cat c = (Cat)a;        // 向下转型  
          c.work();        // 调用的是 Cat 的 work
}  

public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
     }  
}

abstract class Animal {  
    abstract void eat();  
}  

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("看家");  
    }  
}

运行结果

吃鱼

抓老鼠

吃骨头

看家

吃鱼

抓老鼠

多态的实现方式

• 重写
• 接口
• 抽象类和抽象方法

总结

Java面向对象的四大特性在我们平时编程中随处可见的，务必理解、掌握，在理解和掌握的基础上进行实操，那么你在编程时就游刃有余了。 因为文章的篇幅有点长，学习完Java也有很长一段时间了，过程肯定会有所瑕疵，还请各位大神补充，最后，感谢每一位看完整篇文章的人，谢谢你们的支持!!!!