Java的三大特性：继承、封装、多态

*Java的三大特性：继承、封装、多态

1. 封装
   1.尽可能隐藏对象的内部实现细节，控制对象的修改及权限访问。
   2.访问修饰符：private（可将属性修饰为私有，仅本类可见），私有属性在类的外部不可以访问。可以通过get/set方法。

public class Test{
	public static void main(String []args){
	Student stu = new Student();
	//The filed Student.age is not visible
	//stu.age;//出现报错私有属性在类的外部不可以访问
	}
}

class Student{
	String name;
	String sex;
	private int age;//将age属性设置为私有
}

3. 在私有类的内部提供get/set方法，可以保证数据的正常录入，在方法内部添加逻辑判断，可以保证数据安全。

public class Test{
	public static void main(String []args){
		Cat cat = new Cat();
		//set/get 方法的使用
		cat.setName("喵喵");
		cat.getName();
		System.out.println(cat.getName());
	}
}

class Cat {
	private String name;
	private String type;
	// alt+command +s Mac
	// alt+shift+s windows 快速调用get/set方法
	private int intimacy;
	private String sex;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

2.继承

1. 继承必须满足 is ,a 的关系。
2. 程序中的继承，是类与类特征和行为之间的一种赠与获得。
3. 产生继承关系之后，子类可以使用父类中的属性和方法，也可以定义子类独有的属性和方法。
4. 好处：提高了代码的复用性，也提高了代码的可扩展性。
5. 父类：在一组相同或者相似的类中，提取共有的属性和方法，实现重用。语法，class 子类 extends 父类{ } 。
6. Java 为单继承，一个类只能有一个直接子类但是可以多级继承，属性和方法逐级叠加。
7. 继承中先创建父类对象，再创建子类对象。

不可继承：

1. 构造方法，类中的构造方法，只负责创建本类对象，不可继承。
2. private 修饰的属性和方法。
3. 父类子类不在同一个包中，default修饰的属性和方法。

访问修饰符权限

方法的重写和重载：

• [ ]重写
  1、方法名相同，参数列表相同，返回值类型相同。
  2、访问修饰符和父类相同或者比父类更宽。
  3、返回值类型和父类一样，或者是返回其子类。

class Father{
	String name;
	
	public Father eat() {
		Father father = new Father();
		return father;
	}
}

class Son extends Father{
	@Override
	public Son eat() {
		// TODO Auto-generated method stub
		Son son = new Son();
		return son;
	}
}


class Daughter extends Father{
	@Override
	public Father eat() {
		// TODO Auto-generated method stub
		Father father = new Father();
		return father;
	}
}

• [ ]重载
  1、方法名相同，参数列表不同。—>数据类型，个数，顺序不同。
  2、和访问修饰符和返回值无关。

class Father{
	String name;
	int age;
	//重载
	public void eat(String name){
	}
	public void eat(String name,int age){
	}
	//构造方法重载
	public Father(){
	}
	public Father(String name){
	}
}

class Son extends Father{
	String name;
	int age;
	public void eat(String name,int age){
	}
}

super 关键字

1. super.父类属性。super.父类方法( );调用父类属性和方法。
2. super( )。super(实参）;调用父类构造方法。
3. 如果子类构造中，没有显示定义super，或者super（实参）。则默认提供super
4. 同一个子类构造中，super 和 this 不可以同时存在。
5. super 和 this 用在构造方法中的时候 ，必须在首行。

 class A{
 	public void eat(){
 		//100行代码写类中eat的方法
 	}
 }
class B extends A{
	public void eat(){
		super.eat();//父类中100行代码
		//新增一行子类中独有的代码
	}
 

3.多态

1. 概念：父类的引用指向子类的对象，从而实现多态。父类的引用仅可以调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

public class Test{
	public static void main(String []args){
		//这就是父类的引用指向了子类的对象
		Animal animal = new Dog();
		//Animal animal  :父类引用
		//new Dog()  :  子类对象
	}
}

class Animal{
	String name;
	public void eat(){
	}
}

class Dog extends Animal{
	public void eat(){
		super.eat();
	}
}

1. 实现多态的必要条件：（1）继承。（2）子类重写了父类。（3）父类的引用指向了子类的对象。
2. 多态的应用。
   2.1方法一：使用父类作为方法的形参实现多态，使方法的参数类型更加广泛。

//这里的是前提条件
class Animal{
	String name;
	String weight;
	
	public void eat() {
		System.out.println("动物吃");
	}
}

class Dog extends Animal{
	//重写父类Animal中的eat方法
	public void eat() {
		// TODO Auto-generated method stub
		super.eat();
		System.out.println("狗在吃");
	}
	//子类Dog类中独有的方法
	public void breakHome() {
		System.out.println("狗在拆家");
	}
}

//这些是之前的写法，为了完成各种动物的喂食方式，需要多个重载
public void feed(Dog dog) {
		System.out.println("喂食");
		dog.eat();
}	

public void feed(Snake snake) {
		System.out.println("喂食");
		snake.eat();
}
	
public void feed(Bird bird) {
		System.out.println("喂食");
		bird.eat();
}
	
public void feed(Cat cat) {
		System.out.println("喂食");
		cat.eat();
}

//使用了多态之后的写法

public void feed(Animal animal){
	animal.eat();
}

//使用父类作为方法的形参传值，
//只需要写一个feed方法，就可以完成各种动物的喂食.
public class Test {
	public static void main(String[] args) {
		
		//实例化主人类
		Master m = new Master();
		Dog dog = new Dog();
		Bird bird= new Bird();
		Snake snake = new Snake();
		Cat fish = new Cat();
		//父类对象调用子类实例方法
		m.feed(dog);
		m.feed(bird);
		m.feed(snake);
		m.feed(fish);
	}
}

3.2使用父类的类型作为方法的返回值实现多态，使方法可以返回不同的返回值类型。

public Animal4 sell(int num) {//使用num 记录各种宠物类型
		Animal4 animal = new Animal4();
		if(num == 1) {
			//返回的是狗类
			animal = new Dog();
		}else if(num == 2) {
			//返回的是猫类
			animal = new Cat();
		}else  if(num == 3) {
			animal = new Snake();
		}else
			animal = new Bird();
		return animal;
	}
	
	public void showMenu() {
		System.out.println("欢迎来到宠物店，请输入你要买的宠物");
		System.out.println("输入你要买的宠物1、狗2、猫3、蛇4、鸟");
		Scanner input = new Scanner(System.in);
		int num = input.nextInt();
		//接受sell方法返回的值
		Animal4 animal = sell(num);
		Master master = new Master();
		if(animal != null) {
			System.out.println("购买成功！");
			animal.eat();
		}else if(animal instanceof Dog)
			System.out.println("购买失败！");
	}

3. 多态的好处：（1）良好的扩展性。（2）方便代码维护。（3）代码的灵活性更好。
4. 什么地方去使用多态
   4.1父类作为方法的形参
   4.2父类类中作为方法的返回值
   4.3父类的引用指向子类的实例
5. 向上转型（装箱）：Aniamal a = new Dog( ); a只能使用Animal中的属性和方法。
6. 向下转型（拆箱）：Aniamal a = new Dog( ); Dog dog = (Dog)a; dog 可以使用子类和父类中的属性和方法。