Java基础--抽象、接口、内部类

第一讲 抽象类

一、抽象类的概述

1、抽象类：当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体，为了保证不出问题，方法声明用abstract修饰。

2、抽象类的特点

A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方法，抽象方法只有声明部分而没有具体的方法体。
B：抽象类是不能够被实例化的。不能够创建对象的。
C：如果一个类继承抽象类，那么，它要么重写抽象类中的所有抽象方法，要么本身也是抽象类。

3、抽象类的成员特点

A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)
B：成员方法：抽象类中分为两种方法， * 一种是抽象方法，这种方法在子类中必须要被实现。 * 一种是普通的方法。可以被子类直接继承使用。
C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。它的构造方法有用吗？有，为了让子类实例化的时候使用。

4、抽象类和一般类的不同？

1、该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。
2、抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

5、abstract不能和那几个关键字共同存在？

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。
而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。
可是抽象方法运行没意义。
抽象类中是否有构造函数？
有，抽象类是一个父类，要给子类提供实例的初始化。

6、实例

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 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 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");
}
}

class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("pro work");
}
}

class AbstractDemo
{
public static void main(String[] args)
{
Manager Manager=new Manager("11","10",100,200);
Manager.work();
}
}

二、模板方法设计模式

1、模板方法设计模式

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

2、实例实现

需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模版方法设计模式。

实现：
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();

runcode();

long end = System.currentTimeMillis();

System.out.println("毫秒："+(end-start));
}
public abstract void runcode();//不确定的方法进行暴露出去让子类去完成

}

class SubTime extends GetTime
{

public void runcode()//若子类不是abstract，父类抽象类的方法必须实现
{

for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}

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

第二讲 接口

一、接口的概述

1、接口：当一个类中所有的方法都是抽象的时候，你没必要定义为抽象类，定义为接口就可以了。

接口的格式：interface {}

2、接口的特点：

A：接口是对外暴露的规则
B：接口是功能的扩展
C：接口降低了程序的耦合性。
内聚(自己实现功能的能力)
高内聚，低耦合。
举例：主板和CPU,USB接口,电源插座。
D：扩展说了下接口的理解
狭义的理解就是java中的接口。
广义的理解就是：任何定义的规范都是接口。

3、接口中成员特点

-A：只有成员变量和成员方法。
-B：成员变量 默认修饰符 public static final
int X = 20;
其实是这样的 public static final int X = 20;
-C：成员方法 默认修饰符 public abstract
void show();
其实是这样的 public abstract void show();
建议：为了便于阅读,自己手动加上修饰符。

4、解决了Java中的单继承问题

A：类与类：只能是单继承。 extends
B：接口与接口：可以是单继承，也可以是多继承。 extends
C：类与接口：可以是单实现，也可以是多实现。 implements

5、接口和抽象类的区别

A：抽象类只能被单继承；接口可以被多实现。
B：
--抽象类中的成员：
成员变量:可以是常量，也可以是变量。
成员方法:可以是抽象的，也可以是非抽象的。
构造方法:虽然不可以创建对象，但是可以给子类实例化用。
--接口中的成员：
成员变量：只能是常量。默认修饰符 public static final
成员方法：只能是抽象的。默认修饰符 public abstract
C：抽象类中定义的是体系结构中的共性的内容。接口中定义的是对象的扩展功能。
D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。接口被实现表示的是: "like a"的关系。xx像yy中的一种。

6、实录：student类

A：属性：学号,姓名,年龄
B：方法：学习(study),吃饭(抽象eat),抽烟(是不是所有的学员都抽烟呢?),篮球(是不是所有的人都会打篮球呢?)
分析:学员都具备学习的行为和吃饭的行为,但是并不是所有的学员都抽烟,也不是所有的学员都打篮球
interface Smoking {
public abstract void smoking();
}
interface Sport{
public abstract void playBasketBall();
}
描述的是即会抽烟又会打篮球的学生：SmokeStudent extends Student implements Smoking,Sport

一个类只能继承一个类,但是可以实现多个接口,每实现一个接口,功能就扩展了一部分
class wangwu extends Sport implements Study，Sport
{
}

SmokeStudent ss = new SmokeStudent();
ss.eat();
ss.study();
ss.smoking();
ss.playBasketBall();

第三讲 内部类

一，内部类

1、内部类概述

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。如定义一个描述人的类，而手、心脏等都属于人，然它们又有自己的功能描述，这时可以在人这个描述类中，定义一个描述心脏的类，也就是内部类。
编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test$1.class。编译器将会把内部类翻译成用$（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。

2、内部类的访问规则

1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。

3、访问格式

1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：
外部类名.内部类名  变量名 =外部类对象.内部类对象；
如：    Outer.Inner in =new Outer().new Inner();
当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：
private：将内部类在外部类中进行封装。
static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中，直接访问static内部类的非静态成员的格式为：
new 外部类名.内部类名（）.方法名（）；
如：new  Outer.Inner().function();
在外部其他类中，直接访问static内部类的静态成员格式为：
外部类名.内部类名.方法名（）；
如：Outer.Inner.function();
注意：
1）当内部类中定义了静态成员时，该内部类必须是static的。
2）当外部类中的静态方法访问内部类时，内部类也必须是static的。
3）在实际应用中，内部类通常被定义为private，而很少定义为public。
2、内部类定义在局部
内部类定义在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。
1）不可以被成员修饰符修饰。如public、private、static等修饰符修饰。它的作用域被限定在了声明这个局部类的代码块中
2）可以直接访问外部类中的成员，因为还持有外部类中的引用。
注意：内部类不可以访问它所在的局部中非最终变量。只能访问被final修饰的局部变量。

3、局部定义内部类代码

class Outer
{
int x = 3;

void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}

new Inner().function();

}
}

class  InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);
out.method(8);
}

}
注：为什么上面的代码中打印的值为什么会改变呢？被final修饰的变量的值是不会被改变的。这里类调用方法使用完后，这时这个被final修饰的变量已经从栈内存中消失了，类再次调用这个方法时，已经是另一变量，所以可以重新被传值。

打印结果：4 4

二、匿名内部类

1、匿名内部类概述

1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。  可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。

2、匿名内部类利弊

匿名内部类的利与弊：
好处：简化书写
弊端：1、不能直接调用自己的特有方法、
2、不能做强转动作。
3、如果继承的父类或接口中有很多方法时，使用匿名内部类阅读性会非常差，且调用会很麻烦。所以匿名内部类中定义的方法有一般不超过3个。

3、练习补全代码

interface Inter
{
void method();
}

class Test
{
//补足代码。通过匿名内部类。
/*
static class Inner implements Inter
{
public void method()
{
System.out.println("method run");
}
}
*/
//匿名内部类补全
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("method run");
}
};
}

}

class InnerClassTest
{
public static void main(String[] args)
{

//Test.function():Test类中有一个静态的方法function。
//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
//因为只有是Inter类型的对象，才可以调用method方法。

Test.function().method();

//      Inter in = Test.function();
//      in.method();

/*show(new Inter()
{
public void method()
{
System.out.println("method show run");
}
});

}

public static void show(Inter in)
{
in.method();
}
}

class InnerTest
{

public static void main(String[] args)
{
new Object()
{
public void function()
{
System.out,println("InnerTest ------");
}

}.function();

}*/
}

程序结果：method run