黑马程序员---面向对象（二）（继承）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承概述

package 博客3_面向对象之继承;class Person//定义Person类
{String name;int age;
}
class Student extends Person//学生对象继承于Person
{void Study(){System.out.println("good study");}
}
class Worker extends Person//工人对象继承于Person
{void work(){System.out.println("good work");}
}
public class 继承概述 {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubStudent st = new Student();st.Study();}}

继承的作用：

1，提高了代码的复用性。

2，让类和类之间产生了关系，有了这样的关系，才有了多态的特性。

注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。

java语言中，只支持但继承（接口之间例外），不支持多继承。因为多继承容易带来安全隐患，即当多个类定义了相同功能，但功能内容不同时，子类对象不确定要运行哪个功能。但是java保留了c++这种机制，并用多实现来表示。

java支持多层继承，也就是一个继承体系。

想要使用体系，应先查阅体系中父类的描述，因为父类中定义的是该体系中的共性功能，通过了解共性功能，就可以知道该体系的基本功能。

二、子，父类中变量的特点

1，类中变量的特点

如果子父类中出现非私有的同名成员变量时，子类要访问父类中的同名变量要用super关键字，访问本类对象用this关键字。

2，类中函数的特点

当子类出现和父类一模一样的函数时，子类对象调用该函数就会运行子类函数的内容，即重写，也称覆盖。

当子类继承父类，沿袭了父类的功能，但子类的功能内容与父类不一致时，没有必要定义新功能，而是使用覆盖的特性，保留父类的功能定义，并重写功能内容。

注意：

1，子类覆盖父类，必须保证子类的访问权限大于或等于父类的访问权限，否则编译失败。

2，静态方法只能覆盖静态。

重载和重写的区别：

重载：只看同名函数的参数列表是否相同即可。

重写：子父类方法要一模一样才行。

package 博客3_面向对象之继承;class Fu
{void Study(){System.out.println("study VB");}
}
class Zi extends Fu
{void Study()//重写了父类的方法{System.out.println("study java");}
}
public class 函数重写Demo {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubZi z = new Zi();z.Study();	}
}

在对子类对象进行初始化时，父类的构造函数也会运行。

原因在于子类的构造函数默认的第一行有一条隐式语句super（）；

super（）：会访问父类中空参数的构造函数且子类中所有的构造函数默认第一行都是super（）；

因为父类中的数据子类可以直接获取，所以子类对象子在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，需先访问父类中的构造函数。

如果访问的父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定要定义在子类构造函数的第一行！

结论：子类的所有构造函数，默认都会访问父类中空参数的构造函数，因为子类中每一个构造函数内的第一行都会有隐式的super（）；

三、抽象类

抽象类：当多个类中出现相同的功能，但是功能主体不同时，可以进行向上抽取。这时，只需抽取功能定义，而不抽取功能主体所形成的类，就叫抽象类。

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都被必须被abstract修饰。

3，抽象类不可以用new创建对象，因为调用抽象方法是没有意义的。

4，抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类仍然是抽象类。

抽象类与一般类的区别：

1，抽象类比一般类多了抽象函数，使得抽象类 不可被实例化。

2，抽象类中也可以不定义抽象方法，这样该类就不可以被创建对象。

package 博客3_面向对象之继承;abstract class Phone//创建抽象类
{abstract void show();
}
class IPhone extends Phone
{void show()//复写抽象父类中的show方法{System.out.println("IPhone show");}
}
class WPhone extends Phone
{void show()//复写抽象父类中的show方法{System.out.println("WPhone show");}
}public class 抽象类Demo {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubIPhone ip = new IPhone();WPhone wp = new WPhone();ip.show();wp.show();}}

模板方法模式：在定义功能时，功能的一部分是确定的，一部分是不确定的而确定的部分需要使用不确定的部分。那么就可以将不确定的部分暴露出去，由该类的子类去完成。

package 博客3_面向对象之继承;abstract class GetTime
{public final void getTime(){long start = System.currentTimeMillis();//获取程序运行开始时间runcode();long end = System.currentTimeMillis();//获取程序运行结束时间System.out.println("毫秒:"+(end-start));}public abstract void runcode();//定义抽象方法
}
class SubTime extends GetTime
{public void runcode(){for(int x = 0 ;x < 4000; x++)//通过for循环让程序多运行一段时间{System.out.println(x);}}
}public class 模板方法设计模式 {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubSubTime st = new SubTime();st.getTime();}}

interface关键字：用于定义接口。

接口中成员的特点：

1，接口中常量用public static final 修饰，可以省略。

2，接口中的方法被public abstract 修饰，也可以省略不写。

implements关键字：实现。接口可以被类实现。

接口不可以创建对象，因为其中有抽象方法。接口需要被子类实现，并且将接口中的抽象方法全部覆盖后，子类才可以被实例化，否则子类还是一个抽象类。

注意：接口与接口之间是继承关系，并且是java中唯一的多继承。
接口的特点：

1，接口是对外暴露的规则

2，接口是程序的功能扩展

3，接口可以被类多实现

4，接口与接口之间是继承关系

package 博客3_面向对象之继承;abstract class Student_2//学生类是抽象的
{abstract void study();//抽象的学习方法，因为每个人学习方式不同void sleep()//共性方法，都要睡觉{System.out.println("sleep");}
}
interface Smoking//一个有抽烟功能的接口，因为不是每个人都会抽烟
{void smoke();
}
class Zhangsan extends Student_2 implements Smoking//张三是个学生，并且会抽烟
{void study(){}public void smoke(){}
}public class InterfaceDemo {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub}}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！