黑马程序员——面向对象3

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

01

(继承概述1)
继承：
1、提高了代码的复用性；
2、让类与类之间产生了关系。有了这个关系，才有了多态的特性。
class Person
{
    String name;
    int age;
}


//关键字extends使Student继承了Person的属性
class Studegt extends Person
{
    void study()
    {
        System.out.println("good study");
    }
}
02
（继承概述2）
JAVA只支持单继承，不支持多继承。
因为多继承容易带来安全隐患。当多个父类中定义了相同功能，功能内容不同时，不确定要运行哪一个。
java保留了多继承机制，并用另一种形式来完成表示，多实现。
java支持多层继承：父类子类孙子类。。。






03
（聚集关系）
聚集：has a（里面有谁）
聚合，组合：多个单体聚成一个团体为聚合。多个部位组成一个整体为组合。球队和身体为例。






04
（字符类中变量的特点）
如果子类中出现非私有的同名变量时。子类要反问本来中的变量用this，子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致，this代表的是本类对象的引用。super代表的是父类对象的引用。






05
(子父类中函数的特点-覆盖)
当子类出现和父类已于一样的函数时，子类对象调用该函数，会运行自雷的函数内容，如同父类的函数被覆盖一样。而实际上父类的函数还在子类里面。
这种情况是函数的另一个特性，重写（覆盖）。
当子类继承父类，沿袭了父类的功能到子类中。但是子类岁具备改功能，但是功能的内容却和父类不一致。这是没必要定义新功能，而是使用覆盖特殊，堡垒父类的功能定义，并重写功能内容。




覆盖：
1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2、静态只能覆盖静态。
重载只看同名函数的参数列表，重写子父类的方法要一模一样。




06
(子父类中构造函数的特点-子类实例化过程)
在对子类对象进行初始化时，父类的构造函数也会运行呢，那是因为子类的构造函数默认第一条有一行隐式的语句super（）；
super（）会访问父类中空参数的构造函数。且子类中所有的构造函数第一行都是super（）。
若父类里面没有空构造函数，那么子类必须要手动指定访问的构造函数。
例如super（3，4）。super语句要写在构造函数的第一行。


子类的所有构造函数默认都会反问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一局隐式的super（）。
当父类中没有空的构造函数时，子类必须手动通过super或者this语句形式来指定要访问的构造函数。
当然子类的够凹函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数访问父类的构造函数。




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




07
（final关键字）
final：最终，作为一个修饰符。
1、可以修饰类，函数，变量。
2、被final修饰的类不可以被继承。为了避免被继承，被子类复写。
3、被final修饰的方法不可以被复写。
4、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起了名字，方便阅读。而这个值不需要改变，所以加上final修饰，常量的书写规定所有的字母都要大写。如果有多个单词组成，单词间通过__链接。
5、内部类定义在流泪中的局部位置上时，只能访问该局部被final修饰的局部变量。


class Demo
{
    final int X=3;
/*被final修饰的变量不许大写，用PI增强阅读性.既然PI值已确定，那么用定义成静态节约空间，且无法修改，用public也无妨*/
    public static final double PI=3.14;
    final void show1() //final修饰，不让子类重写
    {}
    void show2()
    {   
        final int Y=4;
//y=4 错误，只能被赋值一次
        System.out.println(3.14)//3.14让人不明所以，改用PI
    }

}
class SubDemo extends Demo
{
//void show1(){}  父类方法被final修饰，无法重写

}




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


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

class BaseStudent extends Student

{
    void study()
    {
        System.out.println("base study");
    }
/*子类也继承了父类的study1(),所以在子类的class前也要加abstract修饰.若不想类也被abstract修饰，就必须让子类的study1（）复写，void study1(){}，这样子类中就没有抽象成员，类也就不用抽象关键字修饰*/
//abstract void study1();
}


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




class AbstractDemo
{
    public static void main(String[] args)
    {
//new student();没意义！
        new BaseStudent().study();
    }
} 






09
(抽象类2)
抽象类比一般类多了个抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。
抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。


10（略）


11
（模板方法模式）
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间，并相减。
获取时间可以用System.currentTimeMillis()。


一个程序，有一部分确定，一部分功能无法确定，那么将这部分功能暴露出来。


abstract class GetTime
{
    piblic final void getTime()//不被子类复写
    {
        long star=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++)
        {
            System.out.println(x);
        }
    }
}


class TemplateDemo
{
    public static void main(String[] args)
    {
        SubTime gt=new SubTime();
        gt.getTime();
    }
}




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


接口定义时，格式特点：
常量public static final
方法：public abstract
类为什么要继承类？
因为父类有东西可以让子类直接拿来用。
接口没有可供子类使用的东西，子类必须实现后才能用。
接口不能创建对象，因为其中有抽象方法。
需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。




接口可以被类多实现。一个类可以实现多个接口。
接口可以继承接口。而且可以多继承。


一个类可以继承


interface Inter
{
//public static final和public abstract可以省略，因为虚拟机会补上缺少的词。为了增加阅读性，最好不要省
    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);
    }
}




14
（接口特点）
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是实现关系，而且类可以继承一个类的同时实现对个接口
接口与接口之间可以有继承关系
总结：类必须的功能定义在父类中，需要扩展的功能定义在接口中。


---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------