黑马程序员——java 面向对象复习笔记（二）

 

java面向对象复习笔记

1、继承

——提高了代码的复用性。
——让类与类之间产生了关系。有了这个关系，才有了多态的特性。

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

 

——通过子类可以扩展父类的功能

class Person            //定义Person类
{
    private String name;
    private int age;
    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;
    }
}
class Student extends Person            //定义Student类继承Person类
{
    private String school;
    public String getSchool()
    {
        return school;
    }
    public void setSchool(String school)
    {
        this.school = school;
    }
}
public class ExtDemo
{
    public static void main(String[] args)
    {
        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(30);
        stu.setSchool("北京大学");
        System.out.println("姓名： " + stu.getName() + ",年龄: " + stu.getAge() + ",学校: " + stu.getSchool());
    }
}

*java中只允许多层继承，不能多重继承。子类不能直接访问父类中的私有成员，子类可以调用父类中的非私有方法。

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

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

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

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

2、子类对象的实例化之前必须首先调用父类中的构造方法后再调用子类自己的构造方法。子类的构造方法中隐含了一个super()的语法。子类中访问父类方法可通过super关键字。

3、方法的重载与覆写的区别

4、this和super的区别

（1）当构造方法又重载时，两者均会根据所给予的参数的类型与个数正确地执行相对应的构造方法。

（2）两者均必须编写在构造方法内的第一行，所以，this()与super()无法同时存在在同一个构造方法内。

5、final关键字

——使用final声明的类不能有子类

——使用final声明的方法不能被子类覆写

——使用final声明的变量即成为常量，常量不可以修改。

——使用final声明变量时要求全部字母大写

6、抽象类的定义及使用规则

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

——包含一个抽象方法的类必须是抽象类

——抽象类和抽象方法都使用abstract关键字声明

——抽象方法只需声明不需要实现

——抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

——抽象类就是比普通类多定义了一个抽象方法，除了不能直接进行对象的实例化操作之外并没有任何的不同。

抽象类例子：

abstract class Student
{
    abstract final void study();
    //abstract void study1();
    void sleep()
    {
        System.out.println("躺着");
    }
}

class ChongCiStudent extends Student
{
    void study()
    {
        System.out.println("chongci study");
    }
}

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();
        new BaseStudent().study();
    }
}

 

7、接口

——特点

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

——接口可以被理解成一种特殊的类由全局常量和公共的抽象方法所组成。

——接口的抽象方法必须定义为public访问权限

——与抽象类一样，接口要通过子类用implements关键字实现

——一个子类可以同时实现多个接口，摆脱了java单继承的局限。

——接口格式

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

范例：

interface InterA
{
    public abstract void show();
}

class Demo
{
    public void function(){}
}

class Test extends Demo implements Inter,InterA
{
    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);

    }
}

 

8、对象的多态性

——多态性在java中主要有两种体现

　　——方法的重载与覆写

　　——对象的多态性

　　　　——向上转型：子类对象—>父类对象

　　　　——向下转型：父类对象—>子类对象

——对象向上转型：父类 父类对象 = 子类实例；

——对象向下转型：子类 子类对象 = （子类）父类实例；

——对象发生向上转型后，所调用的方法一定是被子类覆写过的方法

——对象进行向下转型之前，必须首先发生对象的向上转型

9、抽象类与接口的区别

10、Object类

11、装箱与拆箱

12、总结

（1）继承可以扩充已有类的功能，通过extends关键字实现，可将父类的成员（包括数据成员与方法）继承到子类

（2）java在执行子类的构造方法前会先调用父类中无参的构造方法，其目的是为了对继承父类的成员做初始化的操作。

（3）this()用于在同一类内调用其他的构造方法，而super()则用于从子类的构造方法中调用其父类的构造方法。

（4）重载是指相同类内定义名称相同但参数个数和类型不同的方法。

（5）覆写是指在子类当中定义名称、参数个数与类型均与父类相同的方法，用以覆写父类的方法。