首页 > 编程语言 > 详细

Java基础___面向对象_继承

时间:2020-08-03 23:50:06      阅读:97      评论:0      收藏:0      [点我收藏+]

Java面向对象

继承

继承的概念,继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

类的继承格式
class 父类{
}
class 子类 extends 父类{
}
继承的特性
  • 子类拥有父类非private的属性、方法
  • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展
  • 子类可以用自己的方式实现父类的方法
  • Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类
  • 提高了类之间的耦合性(继承的特点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)
继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有类都是继承与 java.lang.Object ,当一个类没有继承的关键字,则默认继承Object(这个类在 java.lang 包下中,所以不需要 import)祖先类

extends关键及

在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类

public class Animal {
    private String name;
    private int id;
    public Animal(String name, String myid){
        //初始化属性值
    }
    public void eat(){}
    public void sleep(){}
}
public class Dog extends Animal{
}
implements 关键字

使用 implements 关键字可以变相的使 Java 具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)

public interface A{
	public void eat();
	public void sleep();
}

public interface B{
    public void show();
}

public class C implements A,B{
}
super 与 this 关键字

super 关键字:我们可以通过super关键字来实现对父类的访问,用来引用当前对象的父类

this 关键字:指定自己的引用

class Animal{
	void eat(){
        System.out.println("animal : eat");
    }
}

class Dog extends Animal{
    void eat(){
        System.out.println("Dog : eat");
    }
    void eatTest(){
        this.eat();
        super.eat();
    }
}

public class Test{
    public static void main(String[] args){
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
    }
}

输出结果为:

animal : eat
dog : eat
animal :eat
final 关键字

final 关键字声明类可以把类定义为不能继承的,即最终类;或者使用修饰方法,该方法不能被子类重写:

  • 声明类:

    final class 类名{//类体}
    
  • 声明方法:

    修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
    

:实例变量也可以被定义为 final ,被定义为 final 的变量不能被修改。被声明为 fianl 类的方法自动地声明为 final ,但是实例变量并不是 final

构造器

子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显示地通过 super关键字调用父类的构造器并以适当的参数列表。

如果父类构造器没有参数,则在子类的构造器中不需要使用super关键字调用父类构造器,系统会自动调用父类的无参构造器。

class SuperClass{
    private int n;
    SuperClass(){
        System.out.println("SuperClass()");
    }
    SuperClass(int n){
        System.out.println("SuperClass(int n)");
        this.n = n;
    }
}

//SubClass 类继承
class SubCalss extends SuperClass{
    private int n;
    
    SubClass(){//自动调用父类的无参构造器
        System.out.println("Subclass()");
    }
    
    public SubClass(int n){
        super(300);//调用父类的带参的构造器
        System.out.println("SubClass(int n):" + n);
        this.n = n;
    }
}

//SubCalss2 类继承
class SubCalss2 extends SuperClass{
    private int n;
    
    SubClass2(){
        super(300);//调用父类中带参的构造器
        System.out.println("SubClass2()");
    }
    
    public SubClass2(int n){ //自动调用父类的无参的构造器
        System.out.println("SubClass2(int n)" + n);
        this.n = n;
    }
}

public class TestSuperSub{
    public static void main(String[] args){
        System.out.println("---------------SubClass 类继承--------");
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass(100);
        System.out.println("---------------SubClass2 类继承--------");
        SubClass2 sc3 = new SubClass2();
        SubClass2 sc4 = new SubClass2(200);
    }
}

输出结果:

---------------SubClass 类继承--------
SuperClass()
SubClass()
SuperClass(int n)
SubClass(int n):100
---------------SubClass2 类继承--------
SuperClass()
SubClass2()
SuperClass(int n)
SubClass2(int n):200

Java基础___面向对象_继承

原文:https://www.cnblogs.com/Keep-The/p/13430397.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!