继承是面向对象的三大特点之一。
那么，何为继承？
一个类的对象可以使用另一个类的对象中的成员，这种关系就称之为继承。
一：继承格式
继承关键字extends。
/**
* 人类
*/
class person
{
}
/**
* 学生类
*/
class student extends person
{
}
二：继承的优缺点
优点
1：提高了代码的复用性
2：让类与类之间产生了继承的关系，这是构成多态的前提条件。
3：减少代码冗余，增强类的功能扩展性。
缺点
提高了代码的耦合性。在开发中我们遵循：高内聚，低耦合的原则。
高内聚：指一个类的功能越强越好
低耦合：指一个类的关系越少越好
三：继承的特点
1：java只支持单继承，不可以多继承。
/**
* 父亲类
*/
class fu
{
}
/**
* 儿子类
*/
class zi extends fu
{
}
2：java类可以多层继承
/**
* 爷爷类
*/
class ye
{
}
/**
* 父亲类
*/
class fu extends ye
{
}
/**
* 儿子类
*/
class zi extends fu
{
}
3：java类不支持循环继承
/**
* 爷爷类
*/
class ye extends zi
{
}
/**
* 父亲类
*/
class fu extends ye
{
}
/**
* 儿子类
*/
class zi extends fu
{
}
这样写是不可以的。
四：继承后：成员变量、成员方法的访问特点
1：子类不能继承父类中被private关键字所修饰的成员变量和成员方法。
2：子类不能继承父类的构造方法。
3：在子类方法中访问成员（成员变量、成员方法）满足：就近原则，先子类局部范围找 然后子类成员范围找 然后父类成员范围找，如果父类范围还没有找到则报错。
如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？ 可以通过super关键字，指定访问父类的成员。
五：方法重写
Java子类重写父类方法标识： @Override
重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类 （暂时了解 ：缺省 < protected < public）
子类写一个与父类申明一样的方法覆盖父类的方法。 @Override注解可以校验重写是否正确，同时可读性好。
重写方法的名称和形参列表应该与被重写方法一致。 私有方法不能被重写。
重写父类的静态方法会报错的。
public class T06 {
public static void main(String[] args) {
person fu = new person();
student stu = new student();
fu.drink();
stu.drink();
}
}
/**
* 人类
*/
class person
{
public void drink()
{
System.out.println("父类喝水");
}
}
/**
* 学生类
*/
class student extends person
{
@Override
public void drink()
{
System.out.println("子类喝水");
}
}
输出：
父类喝水
子类喝水
六：this、super关键字
| 关键字 | 访问成员变量 | 访问成员方法 | 访问构造方法 |
|---|---|---|---|
| this | this.成员变量 访问本类成员变量 | this.成员方法(…) 访问本类成员方法 | this(…) 访问本类构造方法 |
| super | super.成员变量 访问父类成员变量 | super.成员方法(…) 访问父类成员方法 | super(…) 访问父类构造方法 |
我们先来看下方的代码：
package d0131;
public class T05 {
public static void main(String[] args) {
student stu = new student();
stu.drink();
}
}
/**
* 人类
*/
class person
{
public int i = 1;
public void drink()
{
System.out.println("父类喝水");
}
}
/**
* 学生类
*/
class student extends person
{
int i = 2;
@Override
public void drink()
{
int i = 3;
System.out.println(i);
System.out.println(i);
System.out.println(i);
}
}
控制台输出：
3
3
3
那现在有一个小要求，要求控制台输出3/2/1，我们该如何实现呢？
这其中就需要使用到this以及super关键字。
代码如下所示：
public class T05 {
public static void main(String[] args) {
student stu = new student();
stu.drink();
}
}
/**
* 人类
*/
class person
{
public int i = 1;
public void drink()
{
System.out.println("父类喝水");
}
}
/**
* 学生类
*/
class student extends person
{
int i = 2;
@Override
public void drink()
{
int i = 3;
System.out.println(i);
// 当前这个类的成员变量i
System.out.println(this.i);
// 父类的成员变量i
System.out.println(super.i);
}
}
输出：
3
2
1
七：构造函数
1：子类的构造函数中，默认都加载了一次父类的构造函数，也就是super()
public class T01 {
public static void main(String[] args) {
zi zi1 = new zi();
zi zi2 = new zi("xh");
}
}
class fu
{
public fu()
{
System.out.println("我被调用了！");
}
private String files;
public String getFiles() {
return files;
}
public void setFiles(String files) {
this.files = files;
}
}
class zi extends fu
{
/**
* 无参构造方法
*/
public zi()
{
// 默认就有一个super方法
// super();
}
/**
* 重载有参构造方法
* @param name
*/
public zi(String name)
{
// 默认就有一个super方法
// super();
}
}
上边的程序，控制台输出：
我被调用了！
我被调用了！
为什么会有这样的现象呢？
因为有继承，说明子类可以使用父类的成员变量，那也就意味着父类的成员变量一定要有一直才可以被使用，所以在创建类对象的时候，会调用子类的构造方法，而子类的构造方法中会先去调用父类的构造方法，目的就是给父类的额成员变量默认初始化
2：子类的所有构造方法中，第一行要么是super（参数），要么是this（参数），他们不可以共存。并且子类中所有的构造方法中至少有一个构造方法里边调用的是super（参数）
class zi extends fu
{
/**
* 无参构造方法
*/
public zi()
{
// 默认就有一个super方法
// super();
this("xxx");
}
/**
* 重载有参构造方法
* @param name
*/
public zi(String name)
{
// 默认就有一个super方法
// super();
this();
}
}
这样写是不行的。编译报错。死循环了属于是。
以上大概就是 java 继承的基本使用。
有好的建议，请在下方输入你的评论。
