{Java初级系列四}---继承接口和抽象类

Posted 2021-03-11 Truman

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了{Java初级系列四}---继承接口和抽象类相关的知识，希望对你有一定的参考价值。

本人为自学Java系列，内容来自于中国大学mooc华东师范大学陈育良教授《Java核心技术》，在此感谢老师！

一：继承

面向对象和面向过程编程语言最大的特点就是变量类型的继承，通过extend去继承父类
继承能够解决很多类型的重复定义，类别内的对象属性和方法都具有一定的共同点。将共同点提取出来，即形成父类/基类/超类—Parent class/Base class/Super class
其他类型则自动生成子类/派生类-----Child class/Derived class

Human类把Man和Woman的height、weight成员属性和eat方法写成一个父类，两个子类就能继承Human，从而节约很多重复定义。
子类会继承父类所有的属性和方法，但是不能访问private成员。
子类会继承父类的父类所有的属性和方法，但是不能访问private成员
单根继承原则：每个类都只能继承一个类，如果不写extends,Java类都默认继承java.lang.object,Objecvt里面默认有clone equlas finalize getcalss hashCode toString等方法
同样方法名和参数情况下，本类的方法会比父类的方法优先级更高

父类：

public class Base {
private int num = 10;
public int getNum() {
return this.num;
}
}

子类：

public class Derived extends Base{
private int num = 20;
public int getNum() {
return this.num;
}
public static void main(String[] args) {
Derived foo = new Derived();
System.out.println(foo.getNum());
}
}

程序返回值为20。子程序会选择本类的方法进行执行。

解释下上章节的继承函数

public class A {
public A() {
System.out.println("11111");
}
public A(int a) {
System.out.println("22222");
}
}

public class B extends A {
public B() {
//super();
System.out.println("333333");
}
public B(int b) {
//super(b);
System.out.println("444444");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
B obj = new B();
System.out.println("==========");
B obj1 = new B(10);
}
}

输出结果：

11111
333333
==========
11111
444444

两个构造器都会默认调用父类的无参构造函数，输入11111.

当我们在每个构造器前面加上super函数，而且super语句必须放在第一条。

当去掉第二行super(b)注释，输出值：

11111
333333
==========
22222
444444

二：抽象类

抽象类：属性+方法组成，完整的类所有的方法都有实现(方法体)，一个完整的类才可以被实例化，如果一个类暂时没有方法实现，就定义为抽象类，抽象类是无法被实例化的。

抽象类关键字abstract声明；
抽象类的组成

--optional 成员变量，个数不限

--optional具体方法，方式有实现，个数不限

-- optional 抽象方法，加abstract关键字，个数不限

同时对于抽象类我们还要遵循以下的规则

抽象类也是类，同样要满足单根继承原则。一个类只能继承一个抽象类
完整类要继承抽象类必须实现其所有的方法，否则只能定义为抽象类

抽象类：

public abstract class Shape {
int area;
public abstract void calArea();
}

完整类继承于抽象类，并实现抽象类中的方法体。

public class Rectangle extends Shape {
int width;
int length;
public void set(int length, int width) {
this.width = width;
this.length = length;
}
public void calArea() {
System.out.println(this.length *this.width);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Rectangle obj = new Rectangle();
obj.set(10,5);
obj.calArea();
}
}

三：接口

紧接继承的定义，如果类的所有方法都没有实现，那么这个类就是接口interface。类只可以继承-extends一个类，但是可以实现-implements多个接口，继承和实现可以同时进行
类可以继承多个接口，没有实现的方法将会叠加，即A继承与B C两个接口，B C两个接口所有方法体将会叠加，如果类没有实现接口所有方法，只能定义为抽象类
接口里可以定义变量，但是一般是常量，详情可以参考final节
这里给大家写几个简单的例子来描述：类-抽象类-接口之间的关系

定义三个接口：

public interface Aninmal {
public void eat();
public void move();
}

接口2：

public interface ClassTree {
public void climb();
}

接口3

public interface CatFamliy extends ClassTree, Aninmal {
// 继承多个接口相当于将没有实现的方法全部叠加
// eat()
// move()
//climb()
}

Cat类是实现与Animanl接口的，必须实现它所有的方法体

public class Cat implements Aninmal {
public void eat() {
System.out.println("Cat can eat");
}
public void move() {
System.out.println("Cat can move");
}
}

类LandAnimal由于只实现Animal中的move方法，没有实现eat方法，定义为abstract类

public abstract class LandAnimal implements Aninmal {
public void move() {
System.out.println("LandAnimal cat move");
}
//public abstract void eat();
}

Rabbit类是先继承LandAnimal抽象类再实现ClassTree接口

public class Rabbit extends LandAnimal implements ClassTree {
// 必须先继承再实现
public void eat() {
System.out.println("Rabbit cat eat");
}
public void climb () {
System.out.println("Rabbit can climb");
}
}

Tiger类是实现CatFamily接口，所以要实现这个接口所有方法

public class Tiger implements CatFamliy {
public void move() {
System.out.println("Tiger can move");
}
public void eat() {
System.out.println("Tiger can move");
}
public void climb() {
System.out.println("Tiger can move");
}
}

四：转型

基本类型转型
变量支持相互转化。比如 int a = (int)3.5 这里进行变量的强转换
基本类型转换：
从高精度往低精度转化，会损失信息，称为收缩变换。这种情况我们需要声明类型转化
从低精度往高精度转化，不损失信息，称为宽松变换。这种情况Java会自动转化。
1. public class Test{
2. public static void main(String[] args) {
3. int a;
4. a = (int)3.5; // 收缩变换
5. System.out.println(a);
6. double b = 3; // 宽松变换
7. System.out.println(b);
8. }
结果：
1. 3
2. 3.0
类转型