接口
可以理解为特殊的抽象类
关键字interface -->接口
接口的优点
- 接口是功能体的集合
- 是一个引用数据类型
- 能够解耦
- 规定开发规范
jdk在1.7之前
属性:
必须是公共的静态的常量 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作用相同
@Override
public void demo2() {
System.out.println("实现了接口02");
}
@Override
public void demo1() {
System.err.println("实现了接口03");
}
}
jdk1.8中新增的内容
在接口中可以定义方法体的方法
- 默认方法: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{
@Override
public void hiring() {
System.out.println("我是经理,我要招人");
}
}
//人事
class Hr implements Hiring{
Manager manager;
//完全可以通过构造函数把真实角色引入到这个代理角色中
public Hr(Manager manager) {
super();
this.manager = manager;
}
@Override
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{
?
@Override
public void make() {
System.out.println("我是造两轮的模板");
}
?
@Override
public void run() {
System.out.println("乌龟");
}
}
class FourCar implements Car{
?
@Override
public void make() {
System.out.println("我是造四轮的模板");
}
?
@Override
public void run() {
System.out.println("飞一样的感觉");
}
}
内部类
- 成员内部类
- 静态内部类
- 私有内部类
- 局部内部类
- 匿名内部类
成员内部类
当内部类作为外部类的成员,就是成员内部类
外部成员----------内部类
特点:
- 是成员就具有成员的特点,就是可以使用成员修饰符修饰
- 是类就有类的特点,可以继承及实现
- 内部类可以使用外部列的内容,包括私有的
- 在外部类中可以通过内部类的对象使用其成员
- 成员内部类中不能定义静态内容除了静态常量
私有内部类
- 私有内部类可以使用外部类中的私有内容
- 外部类中可以使用私有内部了中的私有内容,需要通过内部类对象使用
- 私有的内部类中只能在外部类中使用,其他类中无法使用
静态内部类
- 只有静态内部类中可以定义静态的内容,除了静态的内容
- 静态内部类中使用外部类中的成员,通过外部类对象使用,因为内部类是静态
局部内部类
- 方法中的内部列
- 不能使用成员修饰符 public static(final可以)
- 局部只能在它当前定义的方法中使用,通过对象使用
- 如果想要在局部内部类中使用当前方法的参数,这个参数必须被final修饰,在jdk1.8中final可以省略,但是默认
匿名内部类
- 匿名内部类
- 匿名对象的内部类
- 方法的参数
原文地址：https://www.cnblogs.com/wuzhaoming/p/11741231.html
时间： 2024-11-08 17:17:43