类的继承
关于类的继承定义,前面多少都有些了解了,可以简单的理解为父亲和儿子的关系,儿子会继承父亲的属性和方法,父亲就是父类,儿子就是子类.他们的关系就是继承关系.
继承是面向对象的重要观念,它的作用是巨大的,它使得程序架构具有一定的弹性,在程序中复用一些已经定义完善的类可以减少软件的开发周期,也可以提高软件的可维护性.
extends和implements关键字
在Java语言中继承可以使用 extends 和 implements (用于继承接口)这两个关键字来实现.
需要注意的是JAVA语言所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
Java语言中,类的继承是单一性的,即entends只能单一继承一个类.而implements的存在就是变相的实现了多继承,即一个类可以继承多个接口.接口会在后面讲到.
实例代码
package java02.day_4_12;
import My_tools.Boundlinetool;
import My_tools.FormatTimetool;
/**
* @outhor xiaoshe
* @date 2019/4/12 - @time 21:36
*/
public class sty_extends {
public
static void main(String[] args) {
father father = new father("小舍的父亲", "工人");
son son = new son("小舍", "男", "程序员");
System.out.println(father.getName());
father.work();
Boundlinetool.Minus();
System.out.println(son.getName());
son.work();
}
}
// 构建父类
class father{
private String name;
private String work;
// 成员方法
public String getName() {
return name;
}
public String getWork() {
return work;
}
public void setName(String name) {
this.name = name;
}
public void setWork(String work) {
this.work = work;
}
//构造方法
public father(String name,String work){
this.work=work;
this.name=name;
}
// 新增方法
public void work(){
System.out.println(this.work);
}
}
// 构建子类
class son extends father{
// 通过extends 继承父类
private String sex;
// 添加新属性.
// 重写构造方法,属性不仅继承了父类属性,还将新属性添加其中.
public son(String name, String sex,String work) {
super(name, work);
this.sex=sex;
}
@Override
// 直接调用父类的成员方法,获取和设置成员属性.
public String getName() {
return super.getName();
}
// 重写父类的work方法
@Override
public void work(){
System.out.println("子类"+super.getName()+"的工作是:");
// 重写内容
super.work();
// 直接调用父类方法.
}
}
重写(Override)与重载(Overload)
重写
就是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
我们在类的继承中知道子类不仅可以继承父类的属性方法,还可以定义自己的属性和方法,并且还可以对父类的方法进行重写,来实现自己的需求.重写在面向对象的思想里占重要的地位.它使程序具有了非常良好的扩展性.可以说能够通过重写方法解决一切问题.重写可以说是继承的一种特性.
// 重写父类的work方法
@Override
public void work(){
System.out.println("子类"+super.getName()+"的工作是:");
// 重写内容
super.work();
// 直接调用父类方法.
}
重载
重载就是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
就是说在类中方法的构建时,可以构建方法名相同而参数不同的方法,这就是方法的重载,重载在类的构造方法中使用的十分常见,我们经常会使用到某些类的构造方法,而且我们会发现通常情况下构造方法都会有很多个,可以通过不同类型的参数构建对象.这就是方法的重载.
多态
多态就是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作.其实继承,重写就是多态的一种体现,我们可以通过不同的子类重写父类的同一个方法来实现不同的结果.
多态的特性:
消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性
多态存在的必要条件,就是继承,重写,父类引用指向子类对象.当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：
可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
多态最常见的实现方式就是通过重写,或继承接口然后实现接口里的方法(其实就是通过重写接口里的方法来实现不同的作用).
抽象类和接口
抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
实例代码
package java02.day_4_12;
/**
* @outhor xiaoshe
* @date 2019/4/13 - @time 0:55
* 抽象类
*/
public class sty_Polymorphism {
public static void main(String[] args) {
woman woman = new woman("女", "黄");
// 尽管不能实例抽象类,但可以实例其子类对象.
System.out.println(woman.getSex());
// 可以直接调用抽象类允许的方法.
System.out.println( woman.getColor());
// 可以直接调用抽象类允许的方法.
}
}
// 定义抽象类人类
abstract class humanity{
// abstact关键字用来定义抽象类
private String sex;
private String color;
public String getSex() {
return sex;
}
public String getColor() {
return color;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setColor(String color) {
this.color = color;
}
humanity(String sex,String color){
//构造方法
this.color=color;
this.sex=sex;
}
@Override
public String toString() {
//重写toString方法
return("性别:"+this.sex+"肤色:"+this.color);
}
}
class woman extends humanity{
// 继承抽象类.woman类可以作为humanity类的一个对象,这就是向上转型.
woman(String sex, String color) {
// 必须要有构造方法.
super(sex, color);
}
}
接口
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
需要注意的是:接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则当该类继承这个接口后要定义接口中的所有方法。
接口同样无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
接口和类的区别:
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口的特性:
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract.
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别:
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
关于抽象方法:
抽象方法就是只有方法名,而没有实现方法的方法体,需要在实现类里重写方法体来实现的方法.
public void work(String work);
接口的定义:
和了id定义类似的接口通过inteface关键字来定义.
interface man{
public void eat();
public void work();
public void play();
}
接口默认就是抽象的(abstract),所以不能实例化,接口的使用,必须被继承,并且其中的方法必须全部被定义实现.才能使用.
实例代码
package java02.day_4_12;
/**
* @outhor xiaoshe
* @date 2019/4/13 - @time 1:35
*/
public class sty_interface {
public static void main(String[] args) {
// 然后可以通过实例化接口的实现类的对象,来调用其方法,
achieveman achieveman = new achieveman();
achieveman.eat();
achieveman.work();
}
}
// 定义一个man接口
interface man{
public void eat();
// 抽象方法
public void work();
}
class achieveman implements man {
// 继承接口后,接口内的方法必须的全部实现
@Override
public void eat() {
System.out.println("男人吃饭");
}
@Override
public void work() {
System.out.println("男人工作");
}
}