java继承,object,final基本使用；

继承继承的概念

根据已有类派生出新类的技术。还能够有本身的独特属性。

为何要使用继承？（优点）

• 代码重用
• 便于维护（高耦合，代码之间紧密联系）

注意：java类只支持单一继承，不容许多继承：即意味着一个父类能够有多个子类，可是子类只能有多个父类

语法：

编写父类

编写子类：在子类加上 extends 父类名称

使用

一：继承父类：子类继承父类的 “全部”成员，就像在本身类中使用

二：子类不能继承父类的：
1. 父类中private修饰的成员
2. 子类和父类不在同一程序包下，使用默认修饰符的成员
3. 构造器。

别称：

父类，超类，基类

子类，派生类

程序设计原则：里氏替换原则

子类是父类，子类彻底替换父类不会出现问题

方法重写

子类中的方法名字，参数，返回值类型与父类中的同样

重写场合

• 子类和父类中的方法的功能不一样
• 子类修改了父类中的功能

重写要注意：
1. .必须 子类
2. 必须是实例成员方法
3. 方法名必须以有
4. 参数同样 或父类擦除后和子类相同
5. 返回值类型和父类相同 或 子类能够是父类的子类型（引用）
6. 子类方法的访问修饰符 不能比父类更严格（低）
7. 异常处理，子类不能比父类异常范围更大

重载和重写的区别

区别点

重载

重写

位置

在同一个类中

在有继承关系的子类中

方法

方法名相同，参数列表不一样，与返回值无关

方法名，参数，返回值类型与父亲一致

做用

方便记忆

修改父亲的功能

英文

overloading

overriding

super

父类的范围

能够调用父类的成员（成员变量，方法）

位置：

子类构造器的第一行代码处

做用

• 区分 子类和 父类同名的成员
• 调用父类构造器，super（）；

super使用注意：子类构造器中没有显示调用父类构造或本类构造，那么系统会自动分配一个super（）调用父类的==无参==构造器

父类中没有无参构造器，只有带参数的构造器，解决办法：
1. 在父类中定义一个无参构造器
2. 显示调用带参构造器，而且传参

this和super的区别和相同点

区别：

一、super()主要是对父类构造函数的调用，this()是对重载构造函数的调用
二、super()主要是在继承了父类的子类的构造函数中使用，是在不一样类中的使用；this()主要是在同一类的不一样构造函数中的使用

相同点：

一、super()和this()都必须在构造函数的第一行进行调用，不然就是错误的

继承的传递：

子类能够继承直接父类的成员，也能够继承间接父类的成员

objectfinalize（）

垃圾回收以前调用

强制垃圾回收：System.gc();

//垃圾回收

package day16_1;

class Student{

    @Override

    protected void finalize() throws Throwable {

        System.out.println("this----->"+this);

        super.finalize();

    }

}

public class TestStudent {

    public static void main(String[] args) {

        Student guojing = new Student();

        System.out.println(guojing);

        //断开

        guojing = null;

        //强制垃圾回收

        System.gc();

        System.out.println(guojing);

    }

}

toString

对象的字符串描述信息

注意：在使用print（）或者println（）输出对象名字时，会自动调用toString

System.out.println(guojing);

System.out.println(guojing.toString());

//重写toString，调用tostring时，输出的是“我爱学习”

    @Override

    public String toString() {

        // TODO Auto-generated method stub

        return "我爱学习";

    }

equals

//重写equals

    @Override

    public boolean equals(Object obj) {

        // 全部的属性值都相同就是同一个对象

        Student stu = (Student)obj;//父类类型强制转换为子类类型

        return this.name.equals(stu.name) &&this.age ==stu.age;

    }

    public class TestStudent {

    public static void main(String[] args) {

        Student guojing = new Student("郭靖",22);

        Student yangkang = new Student("郭靖",22);

        System.out.println(guojing);

        System.out.println(yangkang);

        System.out.println(guojing.equals(yangkang));//object类的equals

        String s = "abc";

        System.out.println(s.equals("def"));//String类下也有equals类，而且是重写的object的

    }

}

final

修饰符：

1. 类，不能被子类继承

- 为了类的安全性，不容许子类修改

- 类之间的方法有复杂的调用关系

- 此类是最终版本的类，不想再扩展了

2. 方法，不能被子类重写

- 不但愿子类更改，全部子类使用的是父类同一版本的方法

3. 变量，值不能更改，这是也就是一个常量

- 对于基本数据类型值不能修改，

- 对于引用类型，不能换对象，对象里的值能够变

Final B b = new B();

b = new B（）；//出错，不能改对象

b.value = 45;//对象的值能够更改

1

2

3

常量的命名规则：全部字母大写，单词之间用下划线链接

常量的好处

（1）安全性，不容许随意更改

（2）好维护，一个常量值更改了，全部应用的地方都改了

（3）加强可读性

什么状况下会派生新类

子类 会增长属性

子类 增长了方法

设计类的继承关系注意

继承关系不要超过三层

能够被子类继承的类

写详细的文档说明

尽可能封装，private；对全部用户都开放，用public；只对子类开放，protected；对全部用户都开放，又不想被子类更改，用final

优势 ：

1.代码重用

2.便于维护

缺点：

1.高耦合

2.破坏封装

组合

总体和局部的关系

//发动机

class Engine{

    public void start(){

        System.out.println("启动");

    }

    public void stop(){

        System.out.println("中止");

    }

}

//轮子

class Wheel{

    public void inflate(int r){

        System.out.println("重气"+ r);

    }

}

//车窗户

class Window{

    public void roolUp(){

        System.out.println("升");

    }

    public void roolDown(){

        System.out.println("降");

    }

}

//车门

class Door{

    Window win = new Window();

    public void open(){

        System.out.println("车开门");

    }

    public void close(){

        System.out.println("车关门");

    }

}

//构造器

class Car{

    Engine e = null;//

    Wheel [] w =null;//

    Door[] d = null;//new Door();

    Car(){

        e = new Engine();

        w =new Wheel[4];

        for(int i = 0;i <w.length;i++){

            w_= new Wheel();_

        }

        d = new Door[2];

        for(int i = 0;i <d.length;i++){

            d= new Door();__

        }

    }

}

public class TestCar {

    public static void main(String[] args) {

        Car car = new Car();

        car.e.start();

        car.e.stop();

        for(int i = 0; i < car.w.length;i++){

            car.w_.inflate(100);_

        }

        car.d[0].open();

        car.d[1].close();

        car.d[2].win.roolDown();

        car.d[3].win.roolUp();

    }

}