CRainyDay

abstract
interface
内部类

一.abstract

abstract: 抽象的, 可以用来修饰类、方法

  1. abstract修饰类: 抽象类
    • 不可被实例化
    • 抽象类有构造器 (凡是类都有构造器)
    • 抽象方法所在的类, 一定是抽象类.
    • 抽象类中可以没有抽象方法.
  2. abstract修饰方法: 抽象方法
    • 格式: 没有方法体和{}.如: public abstract void eat();
    • 抽象方法只保留方法的功能, 而具体的执行, 交给继承抽象类的子类, 由子类重写此抽象方法.
    • 若子类继承抽象类, 并重写了所有的抽象方法, 则此类是一个”实体类”, 即可以实例化
    • 若子类继承抽象类, 没有重写所有的抽象方法, 意味着此类中仍有抽象方法, 则此类必须声明为抽象的!
abstract不能用来修饰属性、构造器、private、final、static

A.模板方法设计模式

功能的内部一部分实现是确定的, 一部分实现是不确定的, 可以将不确定的暴露出去让子类去实现它

点击显/隐内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//模板方法设计模式
public class TestTemplate {
public static void main(String[] args) {
new SubTemplate().spendTime();
}
}
abstract class Template {
//此部分功能不确定: 具体要执行什么代码
public abstract void code();
//此部分功能确定: 计算执行code()方法的时间
public void spendTime() {
long start = System.currentTimeMillis();
this.code();
long end = System.currentTimeMillis();
System.out.println("花费的时间为:" + (end - start));
}
}
class SubTemplate extends Template {
public void code() {
boolean flag = false;
for(int i = 2;i <= 10000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){
flag = true;
break;
}
}
if(!flag){
System.out.println(i);
}
flag = false;
}
}
}

二.interface

接口(interface)是与类并行的一个概念

  1. 接口可以看做是一个特殊的抽象类, 是常量与抽象方法的一个集合, 不能包含变量、一般的方法.
    • 常量默认有 public static final修饰, 方法默认有 public abstract修饰
  2. 接口是没有构造器的.
  3. 接口定义的就是一种功能. 此功能可以被类所实现(implements).
    • 比如: class CC extends DD implements AA
  4. 实现接口的类, 必须要重写其中的所有的抽象方法, 方可实例化. 若没有重写所有的抽象方法, 则此类仍为一个抽象类
  5. 一个类可以实现多个接口.—-java 中的类的继承是单继承的
  6. 接口与接口之间也是继承的关系, 而且可以实现多继承
  7. 接口与具体的实现类之间也存在多态性
  8. 面向接口编程的思想:

A.工厂方法的设计模式

定义一个用户创建对象的接口, 让子类决定实例化哪一个类. 工厂方法使一个类的实例化延迟到其子类.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//接口的应用: 工厂方法的设计模式
public class TestFactoryMethod {
public static void main(String[] args) {
IWorkFactory i = new StudentWorkFactory();
i.getWork().doWork();
IWorkFactory i1 = new TeacherWorkFactory();
i1.getWork().doWork();
}
}
//工厂接口
interface IWorkFactory{
Work getWork();
}
//创建学生工作的工厂
class StudentWorkFactory implements IWorkFactory{
@Override
public Work getWork() {
return new StudentWork();
}
}
//创建老师工作的工厂
class TeacherWorkFactory implements IWorkFactory{
@Override
public Work getWork() {
return new TeacherWork();
}
}
interface Work{
void doWork();
}
class StudentWork implements Work{
@Override
public void doWork() {
System.out.println("学生写作业");
}
}
class TeacherWork implements Work{
@Override
public void doWork() {
System.out.println("老师批改作业");
}
}

B.代理模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//接口的应用: 代理模式(静态代理), 后面会有动态代理
public class TestProxy {
public static void main(String[] args) {
Object obj = new ProxyObject();
obj.action();
}
}
interface Object{
void action();
}
//代理类
class ProxyObject implements Object{
Object obj;
public ProxyObject(){
System.out.println("代理类创建成功");
obj = new ObjctImpl();
}
public void action(){
System.out.println("代理类开始执行");
obj.action();
System.out.println("代理类执行结束");
}
}
//被代理类
class ObjctImpl implements Object{
@Override
public void action() {
System.out.println("=====被代理类开始执行======");
System.out.println("=====具体的操作======");
System.out.println("=====被代理类执行完毕======");
}
}
了解就好, 你可以将这两种设计模式当成算法记下来

三.内部类

类的第5个成员: 内部类(inner class) 例: Thread类内的State枚举类

  1. 相当于说, 我们可以在类的内部再定义类. 外面的类: 外部类. 定义在类内的类: 内部类
  2. 内部类的分类: 成员内部类(声明在类内部且方法外的) vs 局部内部类(声明在类的方法里)
  3. 成员内部类:
    • 是外部类的一个成员: ①可以有修饰符(4个) ②static final ③可以调用外部类的属性、方法
    • 具体类的特点: ①abstract ②还可以在其内部定义属性、方法、构造器
  4. 局部内部类(知道有就好)
  5. 关于内部类, 掌握三点:
    • ①如何创建成员内部类的对象(如: 创建Bird类和Dog类的对象)
    • ②如何区分调用外部类、内部类的变量(尤其是变量重名时)
    • ③局部内部类的使用

A.成员内部类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class TestInnerClass {
public static void main(String[] args) {
//创建静态内部类的对象: 可以直接通过外部类调用静态内部类的构造器
Person.Dog d = new Person.Dog();//区别Person.new Dog();
//Person.Bird b = new Person.Bird();
//创建非静态的内部类的对象: 必须先创建外部类的对象, 通过外部类的对象调用内部类的构造器
Person p = new Person();
Person.Bird b = p.new Bird();
b.info();
b.setName("杜鹃");
}
}
class Person{
String name = "小明";
int age;
//成员内部类(非static的)
class Bird{
String name = "黄鹂";
int id;
public Bird(){
}
public void setName(String name){//假设传过来的参数为"杜鹃"
System.out.println(name);//杜鹃
System.out.println(this.name);//黄鹂
System.out.println(Person.this.name);//小明
}
public void info(){
show();
}
}
//成员内部类(静态内部类)
static class Dog{
}
public void show(){
System.out.println("show()");
}
public void method1(){
class A{
}
}
}

B.局部内部类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class OuterClass{
//局部内部类
//如下的使用方式较少
public void method1(){
class InnnerClass{
}
}
//常常使用一个方法, 使其返回值为某个类或接口的对象. 而这个类或接口在方法内部创建
//使用方式一
public Comparable getComparable(){
//1.创建一个实现Comparable接口的类:局部内部类
class MyComparable implements Comparable{
@Override
public int compareTo(java.lang.Object o) {
return 0;
}
}
//2.返回一个实现类的对象
return new MyComparable();
}
//使用方式二
public Comparable getComparable1(){
//返回一个实现Comparable接口的匿名内部类的对象
return new Comparable(){
@Override
public int compareTo(java.lang.Object o) {
return 0;
}
};
}
}

 评论



本博客所有文章除特别声明外,均采用[(CC BY-NC-SA 4.0)]许可协议。转载请注明出处!

本站使用 Material X 作为主题 , 总访问量为 次 。
Copyright © 2019 CRainyDay's Blog 版权所有