面向对象的特征（封装、继承、多态）

面向对象三大特征:
封装,继承,多态

封装:
将事物的一些特性封装成静态属性,然后把一些行为封装成方法,并且私有化,然后再对外提供可以访问的方法
访问权限修饰符:
访问权限修饰符： private < 默认不写（注意不要添加default修饰）< protected < public
private ：最小权限，被它修饰的成员只能够在本类中可以访问到；
public ：最大权限，任何地方和任何人都能访问；
代码体现:
/
设计方法存值取值
public 需要，给别人访问的
static 不需要：修饰方法，字段也需要静态修饰，静态修饰的字段被该类的所有对象共享
返回值：存值void 不需要返回值，取值对应字段类型
方法名字：存值setName 取值getName : 特殊情况 布尔类型的字段get 变 is
参数：存值对应字段类型，取值不需要参数
/
class Student{
private String name;
private int age;
private boolean sex;
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
public void setSex(boolean s){
sex = s;
}
public boolean isSex(){
return sex;
}
}

封装在Java 中的体现及步骤
1)把类中的字段私有化；
2)给每一个字段都提供一组getter setter方法 (方法的规范写法)；setXxx
在测试类中尝试创建对象,并通过调用getter setter方法完成 对字段的赋值和取值；
3)提供一个无参数的构造方法

二、继承

继承概念来源于现实世界，比如一个人继承了他父母的一些特性，但是他也有一些父母并没有的特性。
概念：在多个子类的基础上，将同性抽离出来放在父类中的过程就叫继承
原则：父类放共性，子类放个性。
在java子类的定义中，使用“extends”关键字，并同时指定父类。
语句格式：class 子类名 extends 父类名{}
class SubClass extends SuperClass{}
可以继承:

字段
普通方法
当修饰符有static和final的时候，也是不能继承的。
当修饰符是private的时候，也是继承了，但是不能直接使用，可以通过public的方法来实现调用。
不能继承：构造方法
继承的特点：
每一个Java类（除了Object类）都有且只有一个直接的父类，如果一个类没有显式的继承另一个类，那么该类的直接父类默认是Object。
Object也是根类，超类。是最大的一个类，形象点就是祖宗。

**class Inherit{ //这里隐藏了extends Object
public static void main(String[] args){
Person p=new Person();//创建对象 调用构造方法。这里没有输出值，构造方不继承
p.name=“小李子”;//赋值名字
System.out.println(p.name);//输出值：小李子
p.eat();//输出值：普通方法继承
}
}
class Animal{//定义了一个类 父类
String name;//属性
int age;//属性
Animal(){
System.out.println(“我是构造方法”)；
}
public void eat(){//定义了一个普通方法
System.out.println(“普通方法继承”);
}
}
class Person extends Animal{//定义了一个属于Animal的子类

}**

三、多态

概念：在继承的基础上，当对象的编译和运行类型不同时，我们把这种现象称为多态。

示例代码：Animal a=new Cat();
1
编译时类型：声明该变量时使用的类型，就表示看做什么类型，这里是Animal。
运行时类型：创建对象的类型，对象的真正类型：Cat。
总结一下就是：编译看左边，运行看右边。
当然前提是继承，左右两边必须是继承的关系，所以继承是多态产生的前提。
作用：当把不同的子类对象都当做父类类型来看，可以屏蔽不同子类对象之间的实现差异，从而写出通用的代码达到通用编程，适应需求的不断变化。

体现方式：

核心本质：Animal a=new Person();

比如，设计一个方法，参数不知道是什么类型，需要判断，然后根据参数的类型，找到其自己对应
的方法，调用实现功能
class Test{
public static void main(String[] args){
Animal a=new Person();
Person p=(Person)a1;
p.eat();
test(a);
Pig p1=new Pig();
test(p1);
}
public static void test(Animal a){ // 这里就是用父类作为参数，避免子类对象之间的差异性
if(a instanceof Person){ //判断a是否属于Person类型
Person p=(Person)a;//强转
p.eat();
}else if (a instanceof Pig){//判断a是否属于Pig类型
Pig p=(Pig)a;//强转
p.eat();
}else{
System.out.println(“不是同类，不能强转”);
}
}
}
class Animal{
}
class Person extends Animal{
public void eat(){
System.out.println(“吃熟食”);
}
}
class Pig extends Animal{
public void eat(){
System.out.println(“拱白菜”);
}
}//返回值提现
Person p=new Person();
public Animal test(){
return p;
}