08-03 java 继承

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

内容给提取出来定义到一个类中。

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

格式：
    class 子类名 extends <a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>名 {}

好处：
    A:提高了<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>的复用性
    B:提高了<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>的维护性
    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()<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>，所以，我们就用继承来体现
        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;私有<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>，子类不能继承</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:子类中的成员变量和<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>中的成员变量<a href="https://www.jb51.cc/tag/mingcheng/" target="_blank" class="keywords">名称</a>不一样，这个太简单。
    B:子类中的成员变量和<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>中的成员变量<a href="https://www.jb51.cc/tag/mingcheng/" target="_blank" class="keywords">名称</a>一样，这个怎么玩呢?
        在子类<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>中访问一个变量的查找顺序：
            <span style="color: #ff0000;"&gt;a:在子类<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>的局部范围找，有就使用
            b:在子类的成员范围找，有就使用
            c:在<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的成员范围找，有就使用
            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的区别?

输出局部范围的num，还要输出本类成员范围的num。怎么办呢? 我还想要输出父类成员范围的num。怎么办呢? 如果有一个东西和this相似，但是可以直接访问父类的数据就好了。恭喜你，这个关键字是存在的：super。

this和super的区别?
    分别是什么呢?
        this代表本类对应的引用。
        super代表<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>存储空间的标识(可以理解为<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>引用,可以操作<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的成员)

    怎么用呢?
        A:<a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>成员变量
            this.成员变量 <a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>本类的成员变量
            super.成员变量 <a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a><a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的成员变量
        B:<a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
            this(...)    <a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>本类的构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
            super(...)    <a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a><a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
        C:<a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
            this.成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a> <a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>本类的成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
            super.成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a> <a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a><a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>

</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;注意：子类每一个构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>的第一条语句默认都是：super();<a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a><a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>

*/
class Father {
int age;

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Father() {
    System.out.println(</span>"Father的无参构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>"<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的带参构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>"<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的带参构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>"<span style="color: #000000;"&gt;);
}

}

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

运行结果：

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

父类没有无参构造方法，那么子类的构造方法会出现什么现象呢? 报错。如何解决呢? 父类中加一个无参构造方法 ------- 方法显示的调用父类的带参构造方法 C:子类通过this去调用本类的其他构造方法子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

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

/
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的带参构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>"<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的带参构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>"<span style="color: #000000;"&gt;);
}

}

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


看程序写结果：

父类的成员 C:子类构造方法执行前默认先执行父类的无参构造方法 D:一个类的初始化过程成员变量进行初始化默认初始化显示初始化构造方法初始化

结果：
    fu   //子类构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>执行前默认先执行<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的无参构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
    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();
}
}

看程序写结果：

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

结果是：
    静态<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>块Fu
    静态<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>块Zi
    构造<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>块Fu
    构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>Fu
    构造<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>块Zi
    构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>Zi

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

{
    System.out.println(</span>"构造<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>块Fu"<span style="color: #000000;"&gt;);
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Fu() {
    System.out.println(</span>"构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>Fu"<span style="color: #000000;"&gt;);
}

}

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

{
    System.out.println(</span>"构造<a href="https://www.jb51.cc/tag/daima/" target="_blank" class="keywords">代码</a>块Zi"<span style="color: #000000;"&gt;);
}

</span><span style="color: #0000ff;"&gt;public</span><span style="color: #000000;"&gt; Zi() {
    System.out.println(</span>"构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>Zi"<span style="color: #000000;"&gt;);
}

}

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

显示初始化构造方法初始化 C:子父类的初始化(分层初始化) 先进行父类初始化，然后进行子类初始化。

结果：
    YXYZ

问题：
    虽然子类中构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>默认有一个super()
    初始化的时候，不是按照那个顺序进行的。
    而是按照分层初始化进行的。
    它仅仅表示要先初始化<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>数据，再初始化子类数据。

*/
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();
}
}

继承中成员方法的关系

方法的关系: A:子类中的方法和父类中的方法声明不一样，这个太简单。 B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢? 调用方法： a:先找子类中，看有没有这个方法，有就使用 b:再看父类中，有没有这个方法，有就使用 c:如果没有就报错。 "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 href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>重载：
    本类中出现的<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>名一样，参数列表不同的<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>。与返回值无关。

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

<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>重写的应用：
    当子类需要<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的<a href="https://www.jb51.cc/tag/gongneng/" target="_blank" class="keywords">功能</a>，而<a href="https://www.jb51.cc/tag/gongneng/" target="_blank" class="keywords">功能</a>主体子类有自己特有<a href="https://www.jb51.cc/tag/neirong/" target="_blank" class="keywords">内容</a>时，可以重写<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>中的<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>。
    这样，即沿袭了<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>的<a href="https://www.jb51.cc/tag/gongneng/" target="_blank" class="keywords">功能</a>，又定义了子类特有的<a href="https://www.jb51.cc/tag/neirong/" target="_blank" class="keywords">内容</a>。

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

*/
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("林青霞");
}
}

方法重写的注意事项：

方法重写的注意事项父类中私有方法不能被重写因为父类私有方法子类根本就无法继承 B:子类重写父类方法时，访问权限不能更低最好就一致 C:父类静态方法，子类也必须通过静态方法进行重写其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

    <span style="color: #ff0000;"&gt;子类重写<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a><a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>的时候，最好声明一模一样。

*/
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.成员方法

使用类继承的案例：

先找到具体的事物，然后发现具体的事物有共性，才<a href="https://www.jb51.cc/tag/tiqu/" target="_blank" class="keywords">提取</a>出一个<a href="https://www.jb51.cc/tag/fulei/" target="_blank" class="keywords">父类</a>。

猫：
    成员变量：姓名，年龄，颜色
    构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：无参，带参
    成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：
        getXxx()/setXxx()
        eat()
        palyGame()
狗：
    成员变量：姓名，年龄，颜色
    构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：无参，带参
    成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：
        getXxx()/setXxx()
        eat()
        lookDoor()

共性：
    成员变量：姓名，年龄，颜色
    构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：无参，带参
    成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：
        getXxx()/setXxx()
        eat()

把共性定义到一个类中，这个类的名字叫：动物。
动物类：
    成员变量：姓名，年龄，颜色
    构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：无参，带参
    成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：
        getXxx()/setXxx()
        eat()

    猫：    
        构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：无参，带参
        成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：palyGame()
    狗：
        构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：无参，带参
        成员<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>：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();


}

}

原文链接：https://www.f2er.com/java/403348.html

猜你在找的Java相关文章