java面向对象多态封装继承_java基础之面向对象(封装，继承，多态)

万物皆对象,在面向对象思想里,封装,继承,多态我。我们真的理解吗?理解完,我们应该怎么用它?什么是面向对象？什么是封装，什么是继承？什么是多态？什么接口？什么是抽象？接口与抽象之间的关系？

java面向对象的三大特征：封装，继承，多态

1、封装：java中的封装是指一个类把自己内部的实现细节进行隐藏，，只暴露对外的接口(getter和setter)方法，封装又分为属性的封装和方法的封装。封装又分为属性的封装和方法的封装，把属性定义为私有地，他们通过setter和getter方法来对属性的值进行设定和获取。

1 public classPerson{2

3 private intid;4 privateString name;5 privatepersion;6

7

8 public intgetId(){9 returnid;}10

11 publicString getName(){12 returnname;}13

14 publicString getPerson(){15 returnperson;16 }17

18 public void setId(intid){19 this.id=id;20

21 }22 public voidsetName(String name){23 this.name=name;24 }25 public voidsetPerson(Person person){26 this.person=person;27 }28

29 }

在Person类中，定义类三个成员变量，分别为id,name,perosn，他们的访问修饰都是private私有的，通过setter和getter方法对这些变量进行设值以及取值。封装的意义就是增强类的信息隐藏与模块化。封装的主要作用是对外部隐藏具体的实现细节，增加程序的安全性。

2、继承

java中的继承是指在一个现有类(父类)的基础上在构建一个新类(子类),子类可以集成父类的成员以及成员方法(但是不一定能访问或调用，例如private的私有地成员变量以及方法不能访问和调用)。继承的作用是能提高代码的复用性。子类拥有父类中的一切(拥有不一定能使用)，它可以访问和使用父类中的非私有成员变量，以及重写父类中的非私有成员方法。

父类：

public classPerson{private int a= 1;父类的私有属性private intid;privateString name;private intage;public intgetID(){returnid;

}public voidsetId(){this.id=id;

}publicString getName(){returnname;

}publicString setName(String name){this.name=name;

}public intAge(){returnage();

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

}

@OverridepublicString toString(){return "Person [id="+id+",name="+name+",age="+age+"]";}

}public voidsay(){

System.out.println("person say");

}public voidrun(){

System.out.println("person run..");

}//父类的私有方法

private voidshow(){

System.out.println(“persion show...”);

}

}

子类：

public class Student extendsPerson{

@Overridepublic voidsay(){super.say();

}

@Overridepublic voidrun(){super.run();

}public static voidmain(String[] args){

Student st= newStudent();//st.show();//子类对象调用父类的私有方法，报错！！！

st.say();

st.run();

}

}

继承的好处是实现代码的复用以及扩展，子类通过对父类代码的复用，可以不用再定义父类中已经定义好多的成员变量，方法上直接对父类的方法进行重写实现了扩展。

3、多态：

多态就是指多种状态，就是说当一个操作在不同的对象时，有产生不同的结果。

在Java中，实现多态的方式有两种，一种是编译时的多态，另一种是运行时多态，编译时的多态是通过方法的重载实现的，而运行时多态是通过方法的重写实现的。

方法的重载是指在同一个类中，有多个方法名相同的方法，但是这些方法有着不同的参数列表，在编译期我们就可以确定 到底调用 了那个方法。

方法的重写，子类重写父类中的方法(包括接口的实现)，父类的引用不仅可以指向父类的对象，而且还可以指向子类的对象。当父类的引用指向子类的引用时，只有在运行时才能确定调用那个方法。

在运行时的多态需要满足三个条件：1、继承(包括接口的实现)；2、方法的重写；3、父类的引用指向子类；

运行时的多态：

接口：(作用：声明方法和常量，不做实现，如果你跟我一样是上面的理解就错了，接口远没有我们想得那么简单，具体请看https://blog.csdn.net/hack_bug/article/details/7634737)

publicinteface Animal{voidshout();

实现类：

public class Dog implementsAnimal{

@Overridepublic voidshout(){

System.out.println("wangwang");

}

}

实现类：

public class Cat implement Animal{

@Override

public void shout(){

System.out.println("喵喵")；

}

}

测试：

public classAnimalTest{public static voidmain(String[] args){//父类的引用指向子类对象

Animal d = newDog();

animalShot(d);//父类的引用指向子类对象

Animal c = newCat();

animalShout(c);

}public static voidanimalShout(Animal animal){

animal.shout();

}

}

父类引用子类的对象:什么是父类引用子类的对象?

Animal a1 =new Dog();父类的引用a1指向了子类的对象new Dog();

就是说Animal是一个接口,或者抽象类,那么是不可以创建对象的,这样写就可以也能后它的引用去指向他子类或者实现类的对象。

假如有一个类，这个类需要实现各种吃水果，有香蕉，苹果，李子等。

public void eat(Banana banana){}

public void eat(Apple apple){}

这样写明显会很麻烦，但是如果这样写

public void eat(Fruit fruit){//}

这样只继承Fruit或者实现Fruit接口，就都可以作为eat的参数，大大简化了编程

面向对象的核心虽然是这短短的六个字，但想把这六个字用活，用好，需要我们不断地学习和认识它。

(在面试的时候，遇到一个优秀面试官，能让菜鸡不断地成长。。。) ，下一节在写写接口啊，抽象啊，再重新认识下。总之，面向对象的开发，是以对象为中心的，额额，我好像还没有对象，自己创建一个把