继承

概念

是指一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用，子类能吸收已有类的数据属性和行为，并能扩展新的能力。

格式

【访问权限修饰符】【修饰符】子类名 extends 父类名{子类体}

作用

• 提高了代码的复用性
• 提高了代码的维护性
• 让类与类产生了一个关系，是多态的前提

缺点

• 让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
  原则：低耦合，高内聚。
  耦合：类与类的关系
  内聚：自己完成某件事情的能力
• 打破了封装性

优点

• Java中类只支持单继承
  class Son exnteds Father {} //正确的
  class Son extends Father,Mother {} // 错误的

• Java中可以多层(重)继承(继承体系)

注意事项：

• 子类不能继承父类的私有成员
• 子类不能继承父类的构造方法，但是可以通过super去访问
• 不要为了部分功能而去继承

使用场景

• 继承体现的是：is a的关系。
• 采用假设法
  如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

抽象

概念

一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

格式

public abstract class 类名()
{
    public abstract void show();//抽象方法没有花括号
}

特点

• 抽象类或者抽象方法由abstract修饰
• 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
• 抽象类不能实例化，因为它不是具体的。
• 抽象类只能做父类，继承抽象类的非抽象类必须实现其中的所有抽象方法
• 抽象类可以有成员属性和非抽象的成员方法
• 构造方法和静态方法不可以修饰为abstract
  原因：构造器抽象了就无法赋值，就没有意义了

成员特点

• 成员变量：有变量，有常量
• 构造方法：有构造方法，用于子类访问父类数据的初始化。
• 成员方法：
  -有抽象，强制要求子类做的事情
  -有非抽象，子类继承的事情，提高代码复用性。

举例

A:猫狗案例练习
实现：从抽象到具体
动物类(抽象类 ): 狗类： 猫类：
成员变量：姓名，年龄 继承自动物类 继承自动物类
构造方法：无参，带参 重写吃饭(); 重写吃饭();
成员方法：吃饭();

abstract class Animal 				//定义抽象的动物类
{
private String name;			//姓名

	private int age;				//年龄

	public Animal() {}
	
	public Animal(String name,int age) 
{
		this.name = name;
		this.age = age;
	}
	
	public String getName() 
{
		return name;
	}
	
	public void setName(String name) 
{
		this.name = name;
	}
	
	public int getAge() 
{
		return age;
	}
	
	public void setAge(int age) 
{
		this.age = age;
	}
	
	public abstract void eat();					//定义一个抽象方法
}

class Dog extends Animal 						//定义具体的狗类
{
	public Dog() {}
	
	public Dog(String name,int age) 
{
		super(name,age);
	}
	
	public void eat() 
{
		System.out.println("狗吃肉");
	}
}

class Cat extends Animal //定义具体的猫类

{
	public Cat() {}
	
	public Cat(String name,int age) 
{
		super(name,age);
	}
	
	public void eat() 
{
		System.out.println("猫吃鱼");
	}
}

class AbstractTest						//测试类
{
	public static void main(String[] args) 
{	//方式1：
		Dog d = new Dog();
		d.setName("旺财");
		d.setAge(3);
		System.out.println(d.getName()+"---"+d.getAge());
		d.eat();
		//方式2：
		Dog d2 = new Dog("旺财",3);
		System.out.println(d2.getName()+"---"+d2.getAge());
		d2.eat();
		System.out.println("---------------------------");
		
		Animal a = new Dog();
		a.setName("旺财");
		a.setAge(3);
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
		
		Animal a2 = new Dog("旺财",3);
		System.out.println(a2.getName()+"---"+a2.getAge());
		a2.eat();
	}
}

抽象方法

定义

在类中没有方法体的方法，就是抽象方法；
含有抽象方法的类，一定是抽象类。

格式

[访问权限] abstract 返回值类型 方法名称(参数列表);

为什么使用抽象方法

如果子类对这个方法的实现都不同，那么在父类就没必要写这个方法的具体实现，相当于在父类中定义了一个规则，所有继承父类的子类都可以使用这个方法。

一个类如果没有抽象方法,却定义为了抽象类，有什么用?

为了不让创建对象

abstract不能和哪些关键字共存

• final 冲突
• static 无意义
• private 冲突

作用

在面向对象领域，抽象类主要用来进行类型隐藏；
在开发项目中创建扩展性很好的架构，优化程序。

多态

概念

对外一种表现形式，内在有多种具体实现

优点

• 提高代码的维护性(继承体现)
• 提高代码的扩展性(多态体现)

缺点

• 子可以当作父使用，父不能当作子使用。

• 解决方法：使用转型
  A:向上转型：从子到父（Fu f = new Zi();）
  B:向下转型：从父到子（Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。）

体现

• 重写
• 重载
• 多态参数

分类

• 具体类多态
  class Fu {}
  class Zi extends Fu {}
  Fu f = new Zi();

• 抽象类多态
  abstract class Fu {}
  class Zi extends Fu {}
  Fu f = new Zi();

• 接口多态
  interface Fu {}
  class Zi implements Fu {}
  Fu f = new Zi();

成员访问特点

• 成员变量
  编译看左边，运行看左边
• 构造方法
  子类的构造都会默认访问父类构造
• 成员方法
  编译看左边，运行看右边
• 静态方法
  编译看左边，运行看左边
• 为什么?
  因为成员方法有重写。

重写（override）

概念

父类中的方法不足以满足子类的需求，子类将父类的方法进行扩展

构造器Constructor不可被重写的原因

• 构造器是用来生成一个类的实例是用来初始化这个实例用的

• 构造器不是方法，那么用来修饰方法特性的所有修饰符都不能用来修饰构造器构造器只能用 public private protected这三个权限修饰符，且不能有返回语句。

• 构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

重载（overload ）

概念

在Java中如果有多个同名但是不同参数的方法就成为“方法的重载”

原则

• 方法名相同
• 参数不同（可以有三方面的不同）
  数量不同 类型不同 顺序不同
• 同一作用域（类）
  注意：方法重载跟方法的返回值类型没有任何关系。

重载和重写的区别

override（重写，覆盖）
（1）方法名、参数、返回值相同。
（2）子类方法不能缩小父类方法的访问权限。
（3）子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
（4）存在于父类和子类之间。
（5）方法被定义为final不能被重写。