java面向对象--07

于 2015-07-25 17:41:50 发布
阅读量272 收藏
点赞数
分类专栏： java 文章标签： extends
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java19930623/article/details/47053285
版权

继承

继承：
1，提高代码的复用性
2，继承让类与类之间产生了关系，有了这个关系，才有了多态的特性。
注意：
不可以为了简化代码，获取其他类的功能无脑继承
必须有所属关系才可以继承。

class Person
{
    String name;
    int age;
}
class Student extends Person
{
    void study()
    {
        System.out.println("good study"+"..."+name+"..."+age);
    }
}
class Worker extends Person
{
    void work()
    {
        System.out.println("goog work");
    }
}

class ExtendsDemo
{
    public static void main(String[] args)
    {
        Student s = new Student();
        s.name = "lisi";
        s.age = 20;
        s.study();  
    }
}

这里写图片描述

继承的特点：

java语言当中，java只支持单继承，不支持多继承
因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当内容功能不相同时，子类不确定要运行哪一个
但是java保留了这种机制，并用另一种体现形式来完成表示：多实现。

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

如何使用一个继承体系中的功能呢？

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

那么在具体调用时，要创建最子类的对象
一是因为有可能父类不能创建对象（如抽象类），
二是创建子类对象，可以使用更多的功能，包括基本的，也包括特有的。

简单一句话就是：查阅父类功能，创建子类对象使用功能。

子父类出现后，类中成员的特点：
类中成员：
1，变量
2，函数
3，构造函数

this:指向本类；super:指向父类

1，变量
如果子父类中出现非私有的同名成员变量时，
子类要访问本类中的变量用this
子类要访问父类中的同名变量用super

super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

class Fu
{
    int num = 4;
}
class Zi extends Fu
{
    int num = 5;
    void show()
    {
        System.out.println(super.num);
    }
    void show1()
    {
        System.out.println(this.num);
    }
}

class ExtendsDemo2
{
    public static void main(String[] args)
    {
        Zi z = new Zi();
        z.show();
        z.show1();
    }
}

2,子父类中的函数

当子类出现和父类一样的函数时，
子类对象调用该函数，会运行子类函数的内容
如同父类函数被覆盖一样。

class fu
{
    void show()
    {a}
}
class zi extends fu
{
    void show()
    {b}
}

运行show，会调用子类中的show。

这种情况是函数的另一个特性：重写（覆盖）

当子类继承了父类，沿袭了父类的功能，到子类中
但是子类虽具备了该功能，但是功能的内容却和父类不一样，
这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

覆盖：
1.子类覆盖父类，必须保证子类权限大于等于父类权限。否则编译失败。

2.静态只能覆盖静态。

重载：只看同名函数参数列表
重写：子父类方法要一致，包括返回值类型

class Tel
{
    void show()
    {
        System.out.println("number");

    }
    void music()
    {

    }
}

class NewTel extends Tel
{
    void show()
    {
        super.show();
        System.out.println("name");
        System.out.println("picture");
    }
}

3,子父类中的构造函数
构造函数不能“覆盖”
在对子类对象进行初始化时，父类的构造函数也会运行

class Fu
{
    Fu()
    {
        System.out.println("fu run");
    }
}

class Zi extends Fu
{
    Zi()
    {
        //super();
        System.out.println("zi run");
    }
}

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

这里写图片描述

那是因为子类的“构造函数”默认第一行有一条隐式的语句 super();所以父类的打印先执行，子类后执行。

super():会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();都会去访问父类的空参数构造函数。

为什么子类要访问父类中的构造函数？
因为父类中的数据子类可以直接获取。所以子类对象建立前，需要先查看父类是如何对这些数据进行初始化的
所以子类在对象初始化时，要先访问一下父类的构造函数 。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定

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

子类的实例化过程：

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

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的父类中有参数的构造函数

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数

final关键字

final:最终
作为修饰符
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承
3，被final修饰的方法不能被重写(复写)
4，被final修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，也可以修饰局部变量。在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起名字，方便阅读。而这个值不需要改变，所以加上final修饰。作为常量：所有字母都大写，如果由多个单词组成，单词间用_连接。
*5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

class Demo
{
    final int x=3;
    final  double PI = 3.14;
    final void show(){}
    void show2()
    {
        final int y=2;
        System.out.println(3.14);
    }
}

抽象类

当多个类中出现相同功能，但是功能主体不同。
这时可以进行向上抽取，只抽取功能定义，而不抽取功能主体。

抽象类的特点：
1，抽象方法一定在抽象类中
2，抽象方法和抽象类都必须被abstract关键字修饰
3，抽象类不可以用new创建对象，因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
例如：

abstract class Student
{
    abstract void study();
    //abstract void study1();
}

class BaseStudent extends Student
{
    void study()
    {
        System.out.println("base study");
    }
}

class AdvStudent extends Student
{
    void study()
    {
        System.out.println("adv study");
    }
}

class AbstractDemo
{
    public static void main(String[] args)
    {
        //new Student();//会报错，Student是抽象的，无法对其实例化。
        new BaseStudent().study();
    }
}
abstract class Student
{
    abstract void study();
    abstract void study1();
}

abstract class BaseStudent extends Student
{
    void study()
    {
        System.out.println("base study");
    }
    //abstract void study1();
}

BaseStudent类继承了Student类，而没有完全复写父类中的抽象方法。这样的话子类也有抽样方法（因为继承）。所以子类也是抽象类

抽象类和一般类没有太大区别，只是抽象类比一般类多了个抽象函数，就是在类中可以定义抽象方法。 抽象类不可以实例化

抽象类中可以不定义抽象方法，这样做可以让类中不建立对象

练习：
假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：
姓名，工号，以及工资。经理也是员工，除了含有员工的属性外，另外还有一个
奖金属性。请使用继承的思想设计出员工类和经理类，要求类中提供必要的方法
进行属性访问。

员工类：name id pay
经理类：继承了员工，并有自己特有的奖金属性（bonus）

abstract class Employee
{
    private String name;

    private String id;

    private double pay;

    Employee(String name,String id,double pay)
    {
        this.name = name;
        this.id = id;
        this.pay = pay;
    }
    public abstract void work();

}
class Manager extends Employee
{
    private int bonus;
    Manager(String name,String id,double pay,int bonus)
    {
        super(name,id,pay);
        this.bonus = bonus;
    }
    public void work()
    {
        System.out.println("manager work");
    }
}
class Pro extends Employee
{
    Pro(String name,String id,double pay)
    {
        super(name,id,pay);
    }
    public void work()
    {
        System.out.println("Pro work");
    }
}
class AbstractTest
{
    public static void main(String[] args)
    {
        //Pro s = new Pro();
        //s.work();
        Manager m = new Manager("lisi","yanfa21",2000.00,500);
        m.work();
        //new Manager().work();
    }
}

接口

接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法全都是抽象的，那么该类可以通过接口的形式来表示
class用于定义类，interface用于定义接口

接口定义时，格式特点:
1.接口常见定义：常量，抽象方法
2.接口中的成员都有固定修饰符
常量：public static final
方法：public abstract
记住：接口中的成员都是public 修饰的。

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

interface Inter
{
    public static final int NUM = 3;
    public abstract void show();
}

class Test implements Inter
{
    public void show(){}
}

class InterfaceDemo
{
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println(t.NUM);
        System.out.println(Test.NUM);
        System.out.println(Inter.NUM);
    }
}

接口可以被类多实现，也是对多继承不支持的转换形式
java支持多实现。

interface Inter
{
    public static final int NUM = 3;
    public abstract void show();
}

interface InterA
{
    public abstract void method();
}

class Demo
{
    public void function(){}
}

class Test extends Demo implements Inter,InterA
{
    public void show(){}
    public void method(){}
}



class InterfaceDemo
{
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println(t.NUM);
        System.out.println(Test.NUM);
        System.out.println(Inter.NUM);
    }
}

类与类之间是继承关系
类与接口之间是实现关系
接口与接口之间是继承关系

interface A
{
    void methodA();
}
interface B //extends A
{
    void methodB();
}
interface C extends A,B
{
    void methodC();
}
class D implements C
{
    public void methodA(){}
    public void methodB(){}
    public void methodC(){}
}
飞鸿踏雪泥-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值