一、继承的引入
继承:
将多个类抽取位一个独立的类,让独立的类和多个类产生继承关系
继承 的关键字:extends
格式:
class 子类名 extends 父类名{
...
}
继承的好处:
1)提供了代码复用性,解决了代码的臃肿
2)它是多态的前提(多态的前提是必须有继承关系)
下来我们通过具体的代码来体会一下继承的好处:
继承之前:...
class Student{
public void study() {
System.out.println("学生在学习....");
}
}
class Teacher{
public void sleep() {
System.out.println("老师在讲课...");
}
}
class programmer{
public void work() {
System.out.println("程序员在codeing...");
}
}
//测试类
public class ExtendsDemo {
public static void main(String[] args) {
//调用study方法
Student s = new Student() ;
s.study();
System.out.println("--------------");
Programmer p = new Programmer() ;
p.work() ;
System.out.println("--------------");
Teacher t = new Teacher() ;
t.teach();
}
}
这样的代码非常臃肿,如果要定义一千种职业呢?难道我们要定义一千个类然后再每个定义吗?为了解决这种问题,Java提供了继承的方法,我们把Student,Teacher,Programmer类的共性抽取出来,重新定义一个Person类,Person类包含study、work、teach方法,然后我们的Student、Teacher、Programmer类只要将Person类继承过去就可以实现之前的方法,因为父类里面包含这些,代码实现如下:
class Person{
private String name ;
public void study() {
System.out.println("学生在学习....");
}
public void teach() {
System.out.println("老师在讲课...");
}
public void work() {
System.out.println("程序员在codeing...");
}
}
//学生类
class Student extends Person{}
//程序员类
class Programmer extends Person{}
//老师类
class Teacher extends Person{}
//测试类
public class ExtendsDemo {
public static void main(String[] args) {
Student s = new Student() ;
s.study();
Programmer p = new Programmer() ;
p.work() ;
Teacher t = new Teacher() ;
t.teach();
}
}
二、继承的特点
继承的特点:
子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的让子类访问它.
继承的另外一个特点:
在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)但是,Java是可以支持多层继承...
类和类之间的关系:继承关系
类和接口之间的关系:实现关系(以后讲)
多层继承的例子:
class GrandFather{
public void function() {
System.out.println("我是爷爷...");
}
}
class Father extends GrandFather{
public void show() {
System.out.println("我是爸爸....");
}
}
//子类
class Son extends Father{ //只支持单继承
//子类有自己特有的玩游戏的功能
public void playGame() {
System.out.println("儿子会玩绝地求生....");
}
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
//测试Son类
Son s = new Son();
s.function();
s.show();
//访问自己的功能
s.playGame();
}
}
Son类继承了Father类,Father类继承了GrandFather类,这就是一种多层继承的关系,子类又有自己单独的方法,所以子类既能调用爷爷类的function功能,又能调用爸爸类的show功能,还能调用自己的playGame功能。
三、继承中的注意事项:
注意事项:
1)构造方法不能被继承,但是通过super关键字去访问
2)父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..(可以使用super)
假设:有一个A类class A{
public void show1(){}
public void show2(){}
}
有一个B类
class B{
public void show1(){}
public void method(){}
}
按照正常的情况:发现A类和B类中有共同的show1()方法,根据继承的概念,---->让B类继承A类
class B extends A{
public void method(){}
}
没有问题,但是继承了A类,show1(),show2()也继承过来了,可能show2()并不是我想要的功能;对于这种情况不要使用继承
继承体现的是一种"is a"的关系:
如果A是B的一种或者B是A的一种,这个可以使用继承!
水果
香蕉
苹果
橘子
人类
学生
老师
军人...
不要随意的使用继承,只要有"is a"的关系就使用它..
Java开发设计原则:
低耦合,高内聚
耦合:类和类之间的关系 ,尽量降低耦合性
内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..)
在继承中,成员变量的名称问题
当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
当子类和父类中的成员变量名称一致的情况:
1)先到子类的局部位置找,如果找到了,就输出
2)没有找到,到子类的成员位置找,有就输出,
3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出
4)如果还没有,就报错了,不存在这个变量
代码举例:
class Fu{
int num = 50 ;
public void method() {
int num = 100 ;
System.out.println(num);
}
}
class Zi extends Fu{
public int num2 =20 ;
//show
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
//测试类
public class ExtendsDemo {
public static void main(String[] args) {
//创建Zi类对象
Zi z = new Zi() ;
z.show();
}
}
输出结果:
50
20
四、super关键字
要访问这个子类的局部位置的变量,直接可以访问.
需求:要访问Son类的成员位置的这个变量nun,如何访问
需求:要访问Father类的成员位置的变量nun.如何访问?
Java提供关键字:super代表的父类的空间标识(父类的引用或父类的对象)
this和super关键字的用法:
成员变量:
this:
this.成员变量; (访问当前类)
super:
super.成员变量;(访问父类)
构造方法:
this(); //无参构造
this("") ;//访问当前类的有参构造
super()://访问的父类的无参构造
super("")://访问的是父类的有参构造..
成员方法:
this.xx()
super.xx()
class Father extends Object{
int num = 100 ;
public Father() {
super();
}
}
//子类
class Son extends Father{
public int num = 50 ;
public void show() {
int num = 20 ;
System.out.println(num);
System.out.println(this.num); //this代表了当前的类对象 :Son
System.out.println(super.num); //super 代表的父类引用
}
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
//创建对象
Son s = new Son() ;
s.show();
}
}
代码运行结果:
20
50100
五、继承中的问题
1、关于继承的成员的问题:
构造方法:子类继承父类,都会默认的访问父类的无参构造方法
假设数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化
class Fu2{
public Fu2() {
System.out.println("父类无参构造方法....");
}
public Fu2(String name) {
System.out.println("父类的有参构造方法...");
}
}
//子类
class Zi2 extends Fu2{
public Zi2() {
// super() ;
System.out.println("子类的无参构造....");
}
public Zi2(String name) {
// super() ;
System.out.println("子类的有参构造....");
}
}
//测试类
public class ExtendsDemo3 {
public static void main(String[] args) {
Zi2 zi = new Zi2() ;
System.out.println("---------------");
Zi2 zi2 = new Zi2("张三") ;
}
}
代码运行结果:
父类无参构造方法....
子类的无参构造....---------------
父类无参构造方法....
子类的有参构造....
子类继承父类,默认访问父类的无参构造!
如果父类的无参构造没有提供?怎么办?
肯定报错;
如何解决:
1)可以将父类的无参构造提供出来
2)可以super关键字去访问父类的带参构造...
3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造
子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!
2、继承中成员方法的问题
子类继承父类,访问成员方法名不一致的情况,分别调用!
当子类中的成员方名和父类中的成员方法名一致的情况:
1)现在子类的成员位置找,如果有就调用
2)如果没有找到,在父类的成员位置找,有就调用
学习了这么多,我们来试着做道题,看看它的输出结果应该是什么:
class X {
Y b = new Y();
X() {
System.out.print("X");//x
}
}
class Y {
Y() {
System.out.print("Y"); //y
}
}
public class Z extends X {
Y y = new Y();
Z() {
// super() ; //这个第一句话super(),this(),默认都在一句话,可以省略....
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}
运行结果:
y
x
y
z
-------------------------------华丽分割线------------------------------------
分析:
首先执行main方法,new一个z对象出来,由于z对象继承了x,所以首先对x进行初始化,x的初始化首先new了一个y对象,所以走y的无参构造,打印y,然后接着对x继续进行初始化,打印x,此时x初始化完毕,执行new y的操作,走y的无参构造打印y,此时再顺序走z的无参构造,打印z。因此打印顺序是y x y z。
六、继承案例
/**
* 猫狗案例的继承版
*
* 猫:
* 属性: 姓名 ,年龄 , 毛色
* 行为: 玩毛线,猫吃鱼...
* ----->Cat 类
* 成员变量:name,age,color
* 成员方法:setXXX/getXXX()
* playGame(),eat()...
* 构造方法:无参/有参
*
* 狗:
* 属性: 姓名 ,年龄 , 毛色
* 行为: 看门,狗吃骨头
* ----->Dog 类
* 成员变量:name,age,color
* 成员方法:setXXX/getXXX()
* playGame(),eat()...
* 构造方法:无参/有参
*
* ---->将共性的内容抽取一个类中, Animal类
*class Animal{
* ...共性内容
*}
*
*Cat类和Dog类分别继承自Animal类
*
* @author Administrator
*
*/
//动物类
class Animal{
private String name ;
private int age ;
private String color ;
//无参
//alt+shift+s-->C
public Animal() {
}
//有参
//alt+shift+s-->O
public Animal(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
//公共的访问方法:alt+shift+s-->R
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat() {
System.out.println("动物吃的方法...");
}
public void sleep() {
System.out.println("动物睡觉的方法...");
}
}
//猫类
class Cat extends Animal{
public Cat() {
super();
}
public Cat(String name, int age, String color) {
super(name, age, color);
}
//自己的功能,吃(吃鱼),当子类定义一个和父类一模一样的方法声明---->继承中的方法重写
public void eat() {//子类覆盖掉父类中eat()方法,显示自己的特有功能
System.out.println("猫吃鱼....");
}
public void playGame() {
System.out.println("猫玩毛线....");
}
public void sleep() {
System.out.println("猫趴着睡觉....");
}
}
//狗类
class Dog extends Animal{
public Dog() {
super();
}
public Dog(String name, int age, String color) {
super(name, age, color);
}
//覆盖方法
public void eat() {
System.out.println("狗吃骨头...");
}
//特有功能
public void lookDoor() {
System.out.println("狗看门...");
}
public void sleep() {
System.out.println("狗躺着睡...");
}
}
//测试类
public class AnimalDemo {
public static void main(String[] args) {
//测试猫类
Cat c = new Cat() ;
c.setName("Tom");
c.setAge(5);
c.setColor("白色");
System.out.println(c.getName()+"----"+c.getAge()+"----"+c.getColor());
c.eat();
c.playGame();
c.sleep();
System.out.println("---------------------------------");
//方式2:
Cat c2 = new Cat("咖啡", 5, "褐色") ;
System.out.println(c2.getName()+"----"+c2.getAge()+"----"+c2.getColor());
c2.eat();
c2.playGame();
c2.sleep();
//狗类
Dog d = new Dog("毛毛",1,"白色");
System.out.println(d.getName()+"----"+d.getAge()+"----"+d.getColor());
d.eat();
d.lookDoor();
d.sleep();
}
}
注意事项:
当子类定义一个和父类一模一样的方法声明---->继承中的方法重写,注意与重载进行区别!
(重载指的是在同一个类中的两个或两个以上的方法,拥有相同的方法名,但是参数却不相同,方法体也不相同。)
六、final关键字
由于子类继承父类的时候,提供一模一样的方法声明,然后会将父类该方法覆盖掉(重写,复写),有时候(具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思
(1)它可以修饰类,那么该类不能继承(2)它可以修饰成员方法,成员方法不能被重写
(3)它可以修饰变量,此时这个变量是一个常量
常量的分类:
字面值常量:
字符串常量,字符常量,,,,
自定义常量(final修饰的)
pubic final int num = 100 ;
(4)final不仅可以修饰基本数据类型,还可以修饰引用类型
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
如果final修饰的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变
final的初始化时机:
被final只能被赋值一次(final int a = 10 )
final int a ;
在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)