黑马程序员-final,抽象,接口

final:最终。作为一个修饰符

   final int x=4; x=4;也是不可以的

   当在描述事物时，一些数据的出现，值是固定的。那么为了增强阅读性，都给这些值起个名字，方便阅读。

   而这个值不需要改变，所以加上final修饰。作为常量；常量的书写规范所有字母都是大写，如果又多个单词组成，

   单词之间通过_链接。例如：final double MY_PI=3.14

应用：

1、final类

       final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。

       在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，

       并且确信这个类不会再被扩展，那么就设计为final类。类可以被fianal,public default三种修饰。

2.如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。但是被final修饰的方法可以被继承。

       使用final方法的原因有二：

       第一、把方法锁定，防止任何继承类修改它的意义和实现。

       第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率

3、final变量（常量）

       用final修饰的【成员变量】表示常量，只能被赋值一次，赋值后值无法改变！

       final定义【局部变量】的时候，可以先声明，而不给初值，这种变量也称为final空白

       如：public void show(){

              final int x;

              x=4;

              System.out.println(x);

       }

       注意：在成员位置时不可以。

4.当函数的参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

       如：

       public void show(final int x){

              System.out.println(x);  

       }

5.内部类定义在类中的局部位置上和匿名内部类，只能访问该局部被final修饰的局部变量。

class outer{

       public void show(){

              int

       class inner      {

              system.out.println(x);

       }}}

        

问题：为什么局部内部类和匿名内部类只能访问被final修饰的局部变量？

       因为对象和局部变量的生命周期不一致。当方法里的局部内部类和匿名内部类所在的方法被调用时，局部变量被加载到栈中，当方法结束，局部变量释放。但是内部的对象还存在（只是没有引用），如果对象还再调用该变量（有方法再使用），那么就找不到变量了。被final修饰有怎样呢？

class lianix {

       public static void main(String[] args)   {

               new Outer().show();

       }

}

class Outer{

       int x = 1;

       public void show(){

              int y=2;

              //new inner();不可以放在这个位置，因为读到这还没有类呢，

              class inner{    

                     inner(){

                            System.out.println(x=x++);//注意x等于1。先赋值在加加。 

                            System.out.println(y);//此时y需要被final修饰。

                     }}

              new inner();

       }}   

抽象。

当多个类中出现相同功能时，但是功能主体不同，即功能相同，内容不同。

但是可以进行向上抽取，这时，只抽取功能定义，而不抽取功能主体。

抽象类：

特点：

1.抽象方法一定在抽象类中。

2.抽象方法和抽象类都必须被abstract关键字修饰。

3.抽象类不可以用new创建对象，因为调用方法没意义。

4.抽象类中方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。

       如果子类只覆盖了部分抽象方法，那么该子类也是抽象类。

抽象类与一般类

       抽象类和一般类没有太大的不同，抽象类比一般类多了个抽象函数。

       该如何描述事物，就如何描述就如何描述。只不过，该事物出现了一些看不懂的东西。

       这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

       通过抽象方法来表示。

特殊：抽象类中可以【不定义抽象方法】，这样做仅仅是为了不让建立对象

多多练习，理解抽象方法。

对员工进行建模，员工包含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 ordinaryEmployee extends Employee{

       ordinaryEmployee(String name,String id,double pay){//这时初始化吗   

               super(name,id,pay);

       }

       public void work(){

              System.out.println("ordinary 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");  

       }}

 //老板不可以继承员工，因为员工的工作不一样，无法具体描述，所以要抽象。

练习：

需求；获取一段程序运行的时间。

原理；获取程序开始和结束的时间并相减。

获取时间；System.currentTimeMillis();

模板设计：

什么是模板方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，

那么就将不确定的部分暴漏出去，让子类去实现。

*/牛

abstract class GetTime{

    public final void getTime()//

    {

        long starttime = System.currentTimeMillis();

        runcode();

        long endtime = System.currentTimeMillis();

        System.out.println("运行时间是"+(endtime-starttime)+"毫秒");

    }

       public abstract void runcode(); //这个要运行的程序可以改变，不确定，所以是抽象的  

}    

class subTime extends GetTime{

       public void runcode(){

              for (int x =0;x<400;x++ ){

            System.out.print(x); 

         }}}

接口；初期理解，可以认为是一个特殊的抽象类

        当抽象类中的方法全是抽象的，那么该类可以通过接口的形式来表示。

class 用于定义类,interface 用于定义接口

接口定义时，格式特点；

       1.接口中常见定义；常量，抽象方法。

       2.接口中的成员都有固定修饰符。

         常量；public static final

         方法；public abstract 

       3.接口中的成员变量都是public的

接口；是不可以被创建对象的，因为有抽象方法。

       需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

       否则子类是一个抽象类。

类与类是继承，类与接口是实现，接口与接口是继承。

       接口的特点：

       2.接口是对外暴露的规则。

       3.接口是程序的功能扩展

       4.类与类之间是继承关系。类与接口之间是实现关系，接口与接口之间是继承关系。

       5.接口可以被类多实现，可以多继承。

注：

多实现要注意方法的同名（参数列表也相同），即使返回值不同也不可以，

因为如果可以，子类要复习两个方法，在调用时不知道调用哪个。

接口与继承的区别：

       继承is a 接口：like a

       基本功能定义在类中，扩展功能定义在接口中。

抽象类和接口的区别：

       1.抽象类在java中继承关系，一个类只可以继承一个抽象类，而接口时是实现

         关系，一个类可以实现多个接口

       2.抽象类表示的是"is-a"关系，interface表示的是"like-a"关系。

       3.抽象类中可以存在非抽象方法，接口不行，都是public abstract，

       4.接口中成员变量都是public static final，必须给定初始化值。