面向对象的三大特征

1封装
1.1定义
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的调用。
1.2原则
1.所有属性隐藏
2.尽可能多的存放，对外提供接口
1.3步骤
1属性前加private修饰符

private int age;

2为private修饰的成员变量添加get/set方法
set:写入 赋值
get:读取 返回

public void setAge(int age){
if(age<0||age>100){
this.age=18;
System.out.print("年龄在0-100之间，默认值18")
return;}
this.age=age;
}

3在main方法中调用
创建对象

p对象名
p.setAge(input.nextInt())
syso(p.getAge())

2继承
2.1关键字
class child extends parent
2.2 object
1任意类型
2所有类的父类
2.3Java继承
子类可以继承父类任何非私有成员（变量，方法，构造）
子类优于父类（有更多成员）
单根性：1个类只存在1个父类
查看继承架构图：ctrl+t
查看类中的所有成员:ctrl+O
2.4关键字
2.4.1native
不是由java实现的，而是由C语言实现的
2.4.2final
常量修饰符
类(该类不能被继承)
方法(该方法不能被子类重写)
2.4.3super
2.4.3.1定义和用法
代表父类的对象，不能用于静态方法
只能出现在子类的方法或构造方法中，用于子类访问父类成员，必须在方法体第一行。
2.4.3.2语法
super():调用父类无参构造（默认隐式调用）
super(参数)：调用父类有参构造
super.属性名：调用父类属性
super.方法名：调用父类方法

3 多态
3.1定义
发生在具有继承关系的实体中，不同实体为了实现同一操作（方法名相同）所采取的不同方式（方法体不同）。
同一引用类型（通常为抽象类，Pet pet Pet引用类型，pet引用变量），使用不同实例（普通子类）执行不同操作（方法）
3.2 里氏替换原则
在出现超类的位置上，可以使用其子类对象。（因为子类优于父类，出现父类的位置都可以用子类替换）
3.3 实现方式
3.3.1父类类型接收子类对象

Animal ani=new Student();
ani.study()//方法调用遵循就近原则

类型对象只能和实际对象强转。
3.3.2父类类型作为方法形参（任意子类可作实参传入）
3.3.3父类类型作为方法返回值
4 例子

package cn.jd;

public abstract class Animal {
public void sport(){
	System.out.println("我是动物，我会运动");
}
}

package cn.jd;

public class Person extends Animal{
public void sport(){
	System.out.println("我是人，我会跑");
}
}

package cn.jd;

public class Student extends Person{
public void sport(){
	System.out.println("我是学生，我会学习");
}
public void study(){
	System.out.println("学习好");
}
public Student(){}
}

package cn.jd;

public class Dog extends Animal {
public void sport(){
	System.out.println("我是狗，爱打架");
}
}

package cn.jd;

public class Factory {
  static Animal bulidAnimal(String name){
	if(name.equals("人")){
		return new Person();//创建了一个人的类
	}else if(name.equals("学生")){
		return new Student();
	}else if(name.equals("狗")){
		return new Dog();
	}else{
		System.out.println("不存在次物种");
		return null;
	}
}
  static Animal creatAnimal(String name){
		switch (name) {
		case "人":
			return new Person();
		case "学生":
			return new Student();
		case "狗":
			return new Student();
		default:
			System.out.println("不存在次物种");
			return null;
		}
	}
}

package cn.jd;
//测试类
public class Practise {
	public static void main(String[] args) {
//	Animal ani=new Student();//自动类型转换，无法调用子类特有成员
//	ani.sport();//就近原则
//	//调用子类特有成员要强制转换
//	if(ani instanceof Student){//关键字instance用于判断，若不用其判断，强转失败显示ClassCastException
//		Student stu=(Student)ani;//类型对象只能和实际对象转换
//		stu.study();
//	}
//	Animal animal=Factory.creatAnimal("人");//语法？父类接收子类，实质是人
//	animal.sport();
//	Animal animal1=Factory.bulidAnimal("学生");
//	animal1.sport();
//	Animal animal2=Factory.bulidAnimal("狗");
//	animal2.sport();
		Person p=new Person();
		animalSport(p);
		Student s=new Student();
		animalSport(s);
		
		
	}
	public static void animalSport(Animal anis){//?静态方法
		System.out.println("动物开始运动");
		anis.sport();
		System.out.println("动物停止运动");}

}