标签：Stub == more 值类型 匿名 round 抽象类 特殊 rate
可以理解为特殊的抽象类
关键字interface -->接口
接口是功能体的集合
是一个引用数据类型
能够解耦
规定开发规范
属性:
必须是公共的静态的常量 public static final
public staic final 可以选择性省略(默认)
方法:必须是公共的抽象的方法
public abstract 返回值类型 方法名();
public absract 可以选择性省略
注意:
接口的实现与类的继承非常像,但是不一样在:
子类继承父类就可以直接使用父类的内容
实现类实现接口,也拥有接口中的能力,但是需要实现列自己去实现这个功能
接口实现的关键字是implement,继承的关键字是extends
类只能单继承,接口可以多实现,一个类需要继承父类后实现接口.
如果先接口后继承,会造成系统无法判断接口的个数.
接口也不能实例化
接口的使用只能通过类去实现接口
具体的实现类:重写了所有的抽象方法+按需新增
抽象类的实现:按需重写了抽象方法+按需新增,具体的子类才能使用
在抽象类中,可以全部实现,也可以部分实现
//抽象实现类
abstract class Demo02 implements InterfaceDemo02{
// @Override
// public void demo2() {
// // TODO Auto-generated method stub
//
// }
}
继承和实现的几种情况
接口和接口之间是可以继承的
类和接口之间只能实现
接口之间可以多继承
类和接口之间可以多实现
//定义一个接口InterfaceDemo02
interface InterfaceDemo02{
public void demo1();
}
//定义一个接口InterfaceDemo03
interface InterfaceDemo03{
public void demo2();
}
//定义一个接口InterfaceDemo04 并继承InterfaceDemo02及InterfaceDemo03
interface InterfaceDemo04 extends InterfaceDemo02,InterfaceDemo03{
}
实现了接口
public class Demo implements InterfaceDemo02, InterfaceDemo03 {//与只实现InterfaceDemo04作用相同
public void demo2() {
System.out.println("实现了接口02");
}
public void demo1() {
System.err.println("实现了接口03");
}
}
在接口中可以定义方法体的方法
默认方法:default关键字修饰(必须是显式的)
使用:通过实现类使用
静态方法
使用:接口名使用
public interface InterfaceDemo05 {
//默认方法
public default void moren(){
System.out.println("我是默认方法");
}
//静态方法
public static void test(){
System.out.println("我是静态方法");
}
}
//实现类
class Impl implements InterfaceDemo05{
}
测试
public class Test {
public static void main(String[] args) {
//默认方法通过类实现
Impl i=new Impl();
i.moren();
//静态方法通过接口名.方法调用
InterfaceDemo05.test();
}
}
保证一个类只能有一个对象,这个特点形式的类成为单例模式,但是不影响类中原有功能.
构造器私有化
私有的 静态的该类引用,存储创建唯一的对象
公共的 静态方法方式
两种方式
当第一次调用的时候才创建这个实例 ---线程不安全,效率较高
示例
//饿汉式
public class SingTon {
//1.构造器私有化
private SingTon(){
}
//2.私有的,静态的该类的引用,存储创建唯一的对象
//在类的第一次加载时候,创建一个唯一的实例
private static SingTon single=new SingTon();
?
//3.公共的 静态的方法方式
//返回值:当前数据类型 参数:没有
private static SingTon newInstance(){
//将当前创建的实例返回出去
return single;
}
}
在类的第一次加载完成之后,就创建这个实例 ---线程安全,效率较低
示例
//懒汉式
public class Single {
//1.私有的构造函数
private Single(){
}
//2.私有的 静态的 该类的引用,存储创建唯一的对象
//先创建一个对象的默认参数为null
private static Single single=null;
//3.公共的静态的该类的引用
public static Single newInstance(){
//先判断实例是不是为空,如果为空则新建
//如果不为空则返回上一次对象的地址
if(single==null){
Single single=new Single();
}
return single;
}
}
真实角色和代理角色实现相同的接口|继承相同的父类
代理角色持有真实角色的引用:成员属性进行维护
代理行为
注意:减少与真实角色的交流,降低耦合度,起到功能的扩展,方便后期维护
/*经理要通过人事招人,相当于 技术部经理 找了 人事当代理
真实角色:经理
代理:人事
行为:招人(人事和经理都需要实现)
代理模式就是把真实角色作为代理角色的一个成员变量
*/
public class StaticProxy {
public static void main(String[] args) {
}
}
//经理
class Manager implements Hiring{
public void hiring() {
System.out.println("我是经理,我要招人");
}
}
//人事
class Hr implements Hiring{
Manager manager;
//完全可以通过构造函数把真实角色引入到这个代理角色中
public Hr(Manager manager) {
super();
this.manager = manager;
}
public void hiring() {
System.out.println("我是人事,我要初试");
//重头戏 把真实角色当成代理模式的一个成员
this.manager.hiring();
System.out.println("成功录取");
}
}
//行为:招人
interface Hiring{
void hiring();
}
//测试
class Test{
public static void main(String[] args) {
Manager m=new Manager();
Hr h=new Hr(m);
h.hiring();
}
?
}
/*
*需求:我们直接从工厂拿车,如果是两轮输出两轮
* 四轮输出四轮
*
*/
public class Factory {
?
public static void main(String[] args) {
Car two=new TwoCar();
Car four=new FourCar();
Factory f=new Factory();
two.make();
f.factory(two);
two.run();
four.make();
f.factory(four);
four.run();
}
/*
有一家工厂可以造两个轮子也可以造四个轮子
一工厂是可以生产车的,这个是一个功能(方法)
结果:确定这个是方法
二工厂是可以生产不同的车的,可以创建不同的对象
结果:确定方法体的内容
三工厂无论生产哪种类型的车都是车,所以返回值一定是车
结果:确定返回值类型
四工厂生产车,需要给输入值
结果:确定参数
*/
//看传入的是否是 TwoCar或ForCar的一个实例
public static Car factory(Car srt){
if(srt instanceof TwoCar){
System.out.println("在造两轮");
}
if(srt instanceof FourCar){
System.out.println("在造四轮");
}
return srt;
}
}
interface Car{
void make();
void run();
}
class TwoCar implements Car{
?
public void make() {
System.out.println("我是造两轮的模板");
}
?
public void run() {
System.out.println("乌龟");
}
}
class FourCar implements Car{
?
public void make() {
System.out.println("我是造四轮的模板");
}
?
public void run() {
System.out.println("飞一样的感觉");
}
}
成员内部类
静态内部类
私有内部类
局部内部类
匿名内部类
当内部类作为外部类的成员,就是成员内部类
外部成员----------内部类
特点:
是成员就具有成员的特点,就是可以使用成员修饰符修饰
是类就有类的特点,可以继承及实现
内部类可以使用外部列的内容,包括私有的
在外部类中可以通过内部类的对象使用其成员
成员内部类中不能定义静态内容除了静态常量
私有内部类可以使用外部类中的私有内容
外部类中可以使用私有内部了中的私有内容,需要通过内部类对象使用
私有的内部类中只能在外部类中使用,其他类中无法使用
只有静态内部类中可以定义静态的内容,除了静态的内容
静态内部类中使用外部类中的成员,通过外部类对象使用,因为内部类是静态
方法中的内部列
不能使用成员修饰符 public static(final可以)
局部只能在它当前定义的方法中使用,通过对象使用
如果想要在局部内部类中使用当前方法的参数,这个参数必须被final修饰,在jdk1.8中final可以省略,但是默认
匿名内部类
匿名对象的内部类
方法的参数
标签：Stub == more 值类型 匿名 round 抽象类 特殊 rate
原文地址：https://www.cnblogs.com/wuzhaoming/p/11741231.html
