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

一、封装

我们平时所熟知的封装概念，一般是把一个东西装到一个容器里面，然后封起来。那面向对象里面的封装又指的是什么呢？其实差不多，有几个关键字，属性，方法，私有化，对外提供可以访问的方法。
概念：将事物的特性封装成属性，将事物的行为封装成方法，字符私有化，并对外提供可以访问的方法。
1.字符指的是成员变量，比如一个人的年龄，姓名，将其私有化，那么就需要用到权限修饰符private，private修饰的内容只能在本类之中访问；private String name; private int age;
2.然后对外提供可以访问的方法，那么方法的修饰符访问权限就必须是最大的public，这里我们通常通过setter和getter来实现，也就是先设置属性值，然后获取属性值。

字段修饰符

• 访问权限：public > protected > default(默认不写) > private
  

标准的JavaBean:

• 需要一个无参构造方法（没有显式构造方法就可以不写）
• 属性必须私有化
• 方法public修饰，方法名命名规范，一般用getter和setter
• 对于boolean类型的成员变量，即布尔逻辑类型的属性，允许使用"is"代替上面的"get"

class Student{
	private String name;//私有属性名字
	private int  age;//私有属性年龄
	Student(){//无参构造方法
	}
	public void setName(String n){//定义方法 设置名字
		this.name=name;//this这里指代当前对象
	}
	public String getName(){//定义方法  返回名字
		return name;
	}
	public void setAge(int a){//定义方法 得到年龄
		this.age=age;
	}
	public int getAge(){//定义方法  返回年龄
		return age;
	}
}

测试得到属性值

class Test{
	public static void main(String[] args){
		Student s= new Student();//创建对象  调用方法
		s.setName("老胡");//调用方法 赋值名字
		System.out.println(s.getName());//调用方法  返回名字
		s.setAge(32);//调用方法 赋值年龄
		System.out.println(s.getAge());//调用方法  返回年龄
	}
}

二、继承

继承概念来源于现实世界，比如一个人继承了他父母的一些特性，但是他也有一些父母并没有的特性。
概念：在多个子类的基础上，将同性抽离出来放在父类中的过程就叫继承
原则：父类放共性，子类放个性。
在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();

编译时类型：声明该变量时使用的类型，就表示看做什么类型，这里是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;
}