08-03 java 继承

发布时间：2020-12-14 06:09:50 所属栏目：Java 来源：网络整理

导读：继承格式，优缺点，概述：如何实现继承呢? Java提供了关键字：extends格式： class 子类名 extends 父类名 {}好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类之间产生了关系，是多态的前提类与类产生了关系，其实也是继承的一个弊端：类的耦

继承格式，优缺点，概述：

如何实现继承呢?    
    Java提供了关键字：extends

格式：
    class 子类名 extends 父类名 {}

好处：
    A:提高了代码的复用性
    B:提高了代码的维护性
    C:让类与类之间产生了关系，是多态的前提

类与类产生了关系，其实也是继承的一个弊端：
    类的耦合性增强了。

    开发的原则：低耦合，高内聚。
    耦合：类与类的关系
    内聚：就是自己完成某件事情的能力

*/

//使用继承前
/*
class Student {
public void eat() {
System.out.println("吃饭");
}

public void sleep() {
    System.out.println("睡觉");
}

}

class Teacher {
public void eat() {
System.out.println("吃饭");
}

public void sleep() {
    System.out.println("睡觉");
}

}
*/

//使用继承后
class Person {
public void eat() {
System.out.println("吃饭");
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; sleep() {
    System.out.println(</span>"睡觉"<span style="color: #000000;"&gt;);
}

}

//格式：class 子类名 extends 父类名 {}
class Student extends Person {}

class Teacher extends Person {}

class ExtendsDemo {
public static void main(String[] args) {
Student s = new Student();
s.eat();
s.sleep();
System.out.println("-------------");

    Teacher t </span>= <span style="color: #0000ff;"&gt;new</span><span style="color: #000000;"&gt; Teacher();
    t.eat();
    t.sleep();
}

}

Java中继承的特点：

有些语言是支持多继承，格式：extends 类1,类2,...

/
class Father {}
class Mother {}
class Son exnteds Father {} //正确的
class Son extends Father,Mother {} // 错误的。因为Java只支持单继承，不支持多继承。
/

class GrandFather {
public void show() {
System.out.println("我是爷爷");
}
}

class Father extends GrandFather {
public void method(){
System.out.println("我是老子");
}
}

class Son extends Father {}

class ExtendsDemo2 {
public static void main(String[] args) {
Son s = new Son();
s.method(); //使用父亲的
s.show(); //使用爷爷的
 }
}

继承的注意实现，什么时候使用继承？

A: B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。 C: class A { public void show1(){} public void show2(){} }

        class B {
            public void show2(){}
            public void show3(){}
        }

        //我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现
        class B extends A {
            public void show3(){}
        }
       <span style="color: #ff0000;"&gt; 这样其实不好，因为这样你不但有了show2(),还多了show1()。
        有可能show1()不是你想要的。</span>

<span style="color: #800080;"&gt;<strong>那么，我们什么时候考虑使用继承呢?</strong></span>
    <span style="color: #ff0000;"&gt;继承其实体现的是一种关系："is a"。</span>
        Person
            Student
            Teacher
        水果
            苹果
            香蕉
            橘子

    <span style="color: #ff0000;"&gt;采用假设法。
        如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

*/
class Father {
private int num = 10;
public int num2 = 20;

</span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;私有方法，子类不能继承</span>
<span style="color: #0000ff;"&gt;private</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; method() {
    System.out.println(num);
    System.out.println(num2);
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; show() {
    System.out.println(num);
    System.out.println(num2);
}

}

class Son extends Father {
public void function() {
//num可以在Father中访问private
// System.out.println(num); //子类不能继承父类的私有成员变量
 System.out.println(num2);
}
}

class ExtendsDemo3 {
public static void main(String[] args) {
// 创建对象
Son s = new Son();
//s.method(); //子类不能继承父类的私有成员方法
 s.show();
s.function();
}
}

继承中成员变量的关系：

继承中成员变量的关系:
    A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。
    B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?
        在子类方法中访问一个变量的查找顺序：
            <span style="color: #ff0000;"&gt;a:在子类方法的局部范围找，有就使用
            b:在子类的成员范围找，有就使用
            c:在父类的成员范围找，有就使用
            d:如果还找不到，就报错。

*/
class Father {
public int num = 10;

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; method() {
    </span><span style="color: #0000ff;"&gt;int</span> num = 50<span style="color: #000000;"&gt;;
}

}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; show() {
    </span><span style="color: #0000ff;"&gt;int</span> num = 40<span style="color: #000000;"&gt;;
    System.out.println(num);
    System.out.println(num2);
    </span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt; 找不到符号</span>

System.out.println(num3);
}
}

class ExtendsDemo4 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
s.show();
}
}

this和super的区别?

this和super的区别?
    分别是什么呢?
        this代表本类对应的引用。
        super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

    怎么用呢?
        A:调用成员变量
            this.成员变量 调用本类的成员变量
            super.成员变量 调用父类的成员变量
        B:调用构造方法
            this(...)    调用本类的构造方法
            super(...)    调用父类的构造方法
        C:调用成员方法
            this.成员方法 调用本类的成员方法
            super.成员方法 调用父类的成员方法

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; show() {
    </span><span style="color: #0000ff;"&gt;int</span> num = 30<span style="color: #000000;"&gt;;
    System.out.println(num);
    System.out.println(</span><span style="color: #0000ff;"&gt;this</span><span style="color: #000000;"&gt;.num);
    System.out.println(</span><span style="color: #0000ff;"&gt;super</span><span style="color: #000000;"&gt;.num);
}

}

class ExtendsDemo5 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}

继承中构造方法的关系：

B:为什么呢?

        <span style="color: #ff0000;"&gt;注意：子类每一个构造方法的第一条语句默认都是：super();调用父类的构造方法

*/
class Father {
int age;

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Father() {
    System.out.println(</span>"Father的无参构造方法"<span style="color: #000000;"&gt;);
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Father(String name) {
    System.out.println(</span>"Father的带参构造方法"<span style="color: #000000;"&gt;);
}

}

class Son extends Father {
public Son() {
//super(); 没写默认有super();语句。子类每一个构造方法的第一条语句默认都是：super();
System.out.println("Son的无参构造方法");
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Son(String name) {
    </span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;super();</span>
    System.out.println("Son的带参构造方法"<span style="color: #000000;"&gt;);
}

}

class ExtendsDemo6 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
System.out.println("------------");
Son s2 = new Son("林青霞");
}
}

运行结果：

继承中构造方法的注意事项：

注意事项：
   <span style="color: #ff0000;"&gt; this(...)或者super(...)必须出现在第一条语句上。
    如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

/
class Father {
/
public Father() {
System.out.println("Father的无参构造方法");
}
*/

<span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Father(String name) {
    System.out.println(</span>"Father的带参构造方法"<span style="color: #000000;"&gt;);
}

}

class Son extends Father {
public Son() {
super("随便给");
System.out.println("Son的无参构造方法");
//super("随便给");
 }

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Son(String name) {
    </span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;super("随便给");</span>
    <span style="color: #0000ff;"&gt;this</span><span style="color: #000000;"&gt;();
    System.out.println(</span>"Son的带参构造方法"<span style="color: #000000;"&gt;);
}

}

class ExtendsDemo7 {
public static void main(String[] args) {
Son s = new Son();
System.out.println("----------------");
Son ss = new Son("林青霞");
}
}


看程序写结果：

结果：
    fu   //子类构造方法执行前默认先执行父类的无参构造方法
    zi
    30
    20
    10

*/
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(super.num); //10
 }
}
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

看程序写结果：

构造代码块 > 构造方法 B:静态的内容是随着类的加载而加载静态代码块的内容会优先执行 C:子类初始化之前先会进行父类的初始化

结果是：
    静态代码块Fu
    静态代码块Zi
    构造代码块Fu
    构造方法Fu
    构造代码块Zi
    构造方法Zi

*/
class Fu {
static {
System.out.println("静态代码块Fu");
}

{
    System.out.println(</span>"构造代码块Fu"<span style="color: #000000;"&gt;);
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Fu() {
    System.out.println(</span>"构造方法Fu"<span style="color: #000000;"&gt;);
}

}

class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}

{
    System.out.println(</span>"构造代码块Zi"<span style="color: #000000;"&gt;);
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Zi() {
    System.out.println(</span>"构造方法Zi"<span style="color: #000000;"&gt;);
}

}

class ExtendsTest2 {
public static void main(String[] args) {
Zi z = new Zi();
}
}

结果：
    YXYZ

问题：
    虽然子类中构造方法默认有一个super()
    初始化的时候，不是按照那个顺序进行的。
    而是按照分层初始化进行的。
    它仅仅表示要先初始化父类数据，再初始化子类数据。

*/
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}

class Y {
Y() {
System.out.print("Y");
}
}

public class Z extends X {
Y y = new Y();
Z() {
//super
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}

继承中成员方法的关系

"show Father"class Son extends Father {
public void method() {
System.out.println("method Son");
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; show() {
    System.out.println(</span>"show Son"<span style="color: #000000;"&gt;);
}

}

class ExtendsDemo8 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
s.show();
s.method();
//s.fucntion(); //找不到符号
 }
}

方法重写的应用：

方法重载：
    本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：
先找子类本身，再找父类。

方法重写的应用：
    当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
    这样，即沿袭了父类的功能，又定义了子类特有的内容。

案例：
    A:定义一个手机类。
    B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
    按照我们基本的设计，我们把代码给写出来了。
    但是呢?我们又发现新手机应该是手机，所以，它应该继承自手机。
    其实这个时候的设计，并不是最好的。
    因为手机打电话功能，是手机本身就具备的最基本的功能。
    所以，我的新手机是不用在提供这个功能的。
    但是，这个时候，打电话功能就没有了。这个不好。
    最终，还是加上这个功能。由于它继承了手机类，所以，我们就直接使用父类的功能即可。
    那么，如何使用父类的功能呢?通过super关键字调用

*/
class Phone {
public void call(String name) {
System.out.println("给"+name+"打电话");
}
}

class NewPhone extends Phone {
public void call(String name) {
//System.out.println("给"+name+"打电话");
super.call(name);
System.out.println("可以听天气预报了");
}
}

class ExtendsDemo9 {
public static void main(String[] args) {
NewPhone np = new NewPhone();
np.call("林青霞");
}
}

方法重写的注意事项：

    <span style="color: #ff0000;"&gt;子类重写父类方法的时候，最好声明一模一样。

*/
class Father {
//private void show() {}

<span style="color: #008000;"&gt;/*</span><span style="color: #008000;"&gt;
public void show() {
    System.out.println("show Father");
}
</span><span style="color: #008000;"&gt;*/</span>

<span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; show() {
    System.out.println(</span>"show Father"<span style="color: #000000;"&gt;);
}
</span><span style="color: #008000;"&gt;/*</span><span style="color: #008000;"&gt;
public static void method() {

}
</span><span style="color: #008000;"&gt;*/</span>

<span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; method() {

}

}

class Son extends Father {
//private void show() {}

<span style="color: #008000;"&gt;/*</span><span style="color: #008000;"&gt;
public void show() {
    System.out.println("show Son");
}
</span><span style="color: #008000;"&gt;*/</span>

<span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; show() {
    System.out.println(</span>"show Son"<span style="color: #000000;"&gt;);
}


</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;static</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; method() {

}

</span><span style="color: #008000;"&gt;/*</span><span style="color: #008000;"&gt;
public void method() {

}
</span><span style="color: #008000;"&gt;*/</span><span style="color: #000000;"&gt;

}

class ExtendsDemo10 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}

方法重写和方法重载的区别?方法重载能改变返回值类型吗?

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为它和返回值类型无关。

Override：方法重写
Overload：方法重载

2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

场景：
成员变量：
this.成员变量
super.成员变量
构造方法：
this(...)
super(...)
成员方法：
this.成员方法
super.成员方法

使用类继承的案例：

先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。

猫：
    成员变量：姓名，年龄，颜色
    构造方法：无参，带参
    成员方法：
        getXxx()/setXxx()
        eat()
        palyGame()
狗：
    成员变量：姓名，年龄，颜色
    构造方法：无参，带参
    成员方法：
        getXxx()/setXxx()
        eat()
        lookDoor()

共性：
    成员变量：姓名，年龄，颜色
    构造方法：无参，带参
    成员方法：
        getXxx()/setXxx()
        eat()

把共性定义到一个类中，这个类的名字叫：动物。
动物类：
    成员变量：姓名，年龄，颜色
    构造方法：无参，带参
    成员方法：
        getXxx()/setXxx()
        eat()

    猫：    
        构造方法：无参，带参
        成员方法：palyGame()
    狗：
        构造方法：无参，带参
        成员方法：lookDoor()

*/
//定义动物类
class Animal {
//姓名
private String name;
//年龄
private int age;
//颜色
private String color;

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Animal() {}

</span><span style="color: #0000ff;"&gt;public</span> Animal(String name,<span style="color: #0000ff;"&gt;int</span><span style="color: #000000;"&gt; age,String color) {
    </span><span style="color: #0000ff;"&gt;this</span>.name =<span style="color: #000000;"&gt; name;
    </span><span style="color: #0000ff;"&gt;this</span>.age =<span style="color: #000000;"&gt; age;
    </span><span style="color: #0000ff;"&gt;this</span>.color =<span style="color: #000000;"&gt; color;
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; String getName() {
    </span><span style="color: #0000ff;"&gt;return</span><span style="color: #000000;"&gt; name;
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; setName(String name) {
    </span><span style="color: #0000ff;"&gt;this</span>.name =<span style="color: #000000;"&gt; name;
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;int</span><span style="color: #000000;"&gt; getAge() {
    </span><span style="color: #0000ff;"&gt;return</span><span style="color: #000000;"&gt; age;
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span> setAge(<span style="color: #0000ff;"&gt;int</span><span style="color: #000000;"&gt; age) {
    </span><span style="color: #0000ff;"&gt;this</span>.age =<span style="color: #000000;"&gt; age;
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; String getColor() {
    </span><span style="color: #0000ff;"&gt;return</span><span style="color: #000000;"&gt; color;
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; setColor(String color) {
    </span><span style="color: #0000ff;"&gt;this</span>.color =<span style="color: #000000;"&gt; color;
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; eat() {
    System.out.println(</span>"不要睡了,该吃饭了"<span style="color: #000000;"&gt;);
}

}

//定义猫类
class Cat extends Animal {
public Cat() {}

</span><span style="color: #0000ff;"&gt;public</span> Cat(String name,String color) {
    </span><span style="color: #ff0000;"&gt;super</span><span style="color: #000000;"&gt;(name,age,color);
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; playGame() {
    System.out.println(</span>"猫玩英雄联盟"<span style="color: #000000;"&gt;);
}

}

//定义狗类
class Dog extends Animal {
public Dog() {}

</span><span style="color: #0000ff;"&gt;public</span> Dog(String name,color);
}

</span><span style="color: #0000ff;"&gt;public</span> <span style="color: #0000ff;"&gt;void</span><span style="color: #000000;"&gt; lookDoor() {
    System.out.println(</span>"狗看家"<span style="color: #000000;"&gt;);
}

}

//测试类
class ExtendsTest5 {
public static void main(String[] args) {
//测试猫
//方式1
Cat c1 = new Cat();
c1.setName("Tom");
c1.setAge(3);
c1.setColor("白色");
System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
c1.eat();
c1.playGame();
System.out.println("---------------");

    </span><span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;方式2</span>
    <span style="color: #ff0000;"&gt;Cat c2 = new Cat("杰瑞",5,"土豪金"</span><span style="color: #000000;"&gt;<span style="color: #ff0000;"&gt;);</span>
    System.out.println(</span>"猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+<span style="color: #000000;"&gt;c2.getColor());
    c2.eat();
    c2.playGame();


}

}

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!