Java笔记2 面向对象<3>final关键字、抽象类、模板方法模式、接口

时间:2023-01-09 19:41:33


07天-07-面向对象(final关键字)

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

1)       可以修饰类、函数、变量;

2)       final修饰的类不能被继承。为了避免被继承,被子类复写功能。例如:String类;

3)       被final修饰的方法不能被重写;

4)       被final修饰的变量时一个常量只能赋一次值,既可以修饰成员变量,又可以修饰局部变量。

  当在描述事物时,一些数据的出现值是固定的,那么这是为了增加阅读性,都给这些值取名字,方便阅读。而这个值不需要改变,所以加上fianl修饰。作为常量,常量的书写规范:所有字符都大写,如果由多个单词组成,单词间通过_连接。

5)       内部类定义在类中的局部位置上,只能访问该局部被final修饰的局部变量。

 

 

07天-08-面向对象(抽象类)

l  什么时候使用抽象类?

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

l  抽象类的特点:

1)       抽象方法一定在抽象类中;

2)       抽象方法和抽象类都必须被abstract关键字所修饰;

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

4)       抽象类中的方法要被占用,必须由子类复写所有的抽象方法后,建立子类对象调用。如果子类只覆盖了部分抽象方法,那么盖子类还是一个抽象类;

l  抽象类和一般类没有太大的不同。

该类如何描述事物,就如何描述事物,只不过,盖世五出现了一些看不懂的东西。这些不确定的部分也是该事物的功能,需要明确出现,但是无法定义主体,就通过抽象方法来表示。

l  抽象类的特殊之处:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象

l  抽象类代码演示:

abstract class YoungPerson {

    abstract void eat();

    abstract void sleep();

}

abstract class Student extends YoungPerson{

    private Stringname;

    public Student(){

       super();

    }

    public Student(String name){

       this.name = name;

    }

    abstract void study();

    public void excise1(){

       if(this.name!=null){

           System.out.println(name+"跑早操!");       

       }else{

           System.out.println("跑早操!"); 

       }

    }

    public static void excise2(){

       System.out.println("做课间操!");

    }

   

}

 

public class BaseTest9 extends Student{

    public BaseTest9(){

       super();

    }

    public BaseTest9(String name){

       super(name);

    }

   

    public static void main(String[] args){

       //new Student();//抽象类不可以创建对象

       BaseTest9.excise2();

       BaseTest9 test = new BaseTest9("haha");

       test.excise1();

      

    }

 

    public void study(){

       System.out.println("正在学习中!");

    }

    public void eat(){

       System.out.println("正在就餐中!");

    }

    public void sleep(){

       System.out.println("正在午睡中!");

    }

   

}

上面的代码展示了以下几个功能:

1)       抽象类可以继承抽象类;

2)       抽象类中既可以定义抽象方法,也可以定义一般方法;

3)       底层类继承一个抽象父类,如果抽象父类还继承了另外一个抽象类,那么底层类必须复写父类的抽象方法和父类的父类的抽象方法,缺一不可;

4)       抽象类不可以创建对象。

 

 

07天-11-面向对象(模版方法模式)

l  什么是模板方法?

在定义功能时,功能的一部分是确定的,但是有一部分是不确定的,而确定的部分再使用不确定的部分,这时就将不确定的部分暴露出去,由该类的子类去完成。

l  模板方法设计模式演示:

/*

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

       原理:或称程序开始和结束的时间并相减既可。

*/

abstract class GetTime{

       publicfinal void getTime(){//用final修饰该方法,限定子类不能复写该方法。

       long start = System.currentTimeMillis();

       runcode();

       long end = System. currentTimeMillis();

       System.out.println(“毫秒:”+(end-start));

}

public abstractvoid runcode();

}

 

class SubTime extends getTime{

       publicvoid runcode(){

       for(int i =0;i<4000;i++){

       System.out.print(i);

}

System.out.println();

}

}

public class TimeDemo{

       publicstatic void main(String[] args){

       SubTime s = new SubTime();

       s.getTime();

       //GetTime g = new GetTime();//抽象类不能实例化对象。

}

}

 

 

07天-12-面向对象(接口)

l  接口格式:

interface 接口名{}

l  接口中的成员修饰符是固定的。

1)       成员常量:public static final

2)       成员函数:public abstract

3)       记住:接口中的成员都是public的。

l  接口的出现将“多继承”通过另外一种形式体现出来,即“多实现”。

l  接口的初期理解:可以认为是一个特殊的抽象类。

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

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

l  接口可以实现多继承,其他类不可以。下面的代码正确:

interface A{

       publicstatic final int num = 3;

       voidmethod1();

}

interface B{

       voidmethod2();

}

interface C extends A,B{

       voidmethod3();

}

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

接上面的代码:

class D implements A,B{

       publicvoid method1(){}

public voidmethod2(){}

 

public staticvoid main(String[] args){

       D test = new D();

       System.out.println(test.num);

       System.out.println(A.num);

}

}

//编译该文件时,会生成3个类文件(interface是特殊的类文件)。

l  总结接口的特点:

1)       接口是对外暴露的规则;

2)       接口是程序的拓展功能;

3)       接口可以用来多实现;

4)       类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口;

5)       接口与接口之间可以有继承关系(既可以单继承也可以多继承)。

 

 

07天-15-面向对象(接口举例体现)

abstract Student{

       abstractvoid study();

       voidsleep(){

       System.out.println(“sleep”);

}

}

interface Smoking{

       voidsmoke();

}

 

class ZhangSan extends Student implementsSmoking{

       voidstudy();

       publicvoid smoke(){}

}

Class lisi extends Student{

       voidstudy(){}

}

//上述代码体现了接口的可拓展性。