1.设计模式
1.单例
1.作用
- 单例模式可以长期保存对象。
- 单例可以传递值：可以让两个对象在完全没有关系的前提下,实现值的传递,降低了耦合性,提高了内聚性。
注：静态方法通过类调用获取 ，所以成员变量设置成静态。
并且有了对象后，防止对象通过。调用成员变量，所以设置为私有。
2.实现
饿汉：直接获取
class SingleInstance{
//2.在单例类的内部创建一个当前类的静态的私有化的对象
//私有：防止获取对象后调用成员变量
//静态：静态方法调用操作静态变量
//只有饿汉式可以加final
private final static SingleInstance s = new SingleInstance();
//1.创建构造方法,并私有化
private SingleInstance() {
}
//3.通过公共的静态的方法将singleInstance对象提供出去
public static SingleInstance getSingleInstace() {
return s;
}
//功能区:
int num;
public void test() {}
}
懒汉：获取时创建
class SingleInstance1{
//2.在单例类的内部创建一个当前类的静态的私有化的对象
private static SingleInstance1 s = null;
//1.创建构造方法,并私有化
private SingleInstance1() {
}
//3.通过公共的静态的方法将singleInstance对象提供出去
public static SingleInstance1 getSingleInstace() {
if (s == null) {
s = new SingleInstance1();
}
return s;
}
}
例子：runtime类
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
2.模板设计
实现功能时分成两部分，一部分确定，一部分不确定。不确定的交给子类，子类实现的结果又会反过来影响确定部分的功能。
public class Demo4 {
public static void main(String[] args) {
zi z = new zi();
z.setFood("青草");
z.func();
}
}
class fu {
public void eat() {
}
public void func() {
System.out.println("要做啥饭？");
eat();
}
}
class zi extends fu {
String food;
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
public void eat() {
System.out.println(food);
}
}
3.适配器模式
1.例子
servlet（5方法接口），General servlet（适配器重写5方法） ，httpservlet（继承一个方法重写）
2.注意
可以视为特殊的装饰设计模式
4.装饰设计模式
装饰设计模式:基于已经实现的功能,提供增强的功能.
装饰设计模式的由来就来自于对缓冲流的实现.
特点:从缓冲流的角度讲解
1.使流原来的继承体更加的简单
2.提高了效率
3.由于是在原有的基础上提高增强的功能,所以他还要属于原来的体系
2.网址
1.组成
- 作用：实现客户端和服务器端的通信
- http协议:超文本传输协议,实现的是网络间的通信的一个通信规则
- https协议:安全的http协议—可以省略,默认是http协议
- 域名/IP:标记网络上的唯一一台主机 可以简化写:baidu
- 端口号:标记同一台主机上的某一个服务器 [0,65536]—可以省,默认80
- 资源路径: 可以省
- 查询条件: 可以省
2.注意
服务器是一个软件，例如tomcat
3.分类
- .com商业机构
- .org 非盈利组织
- .mil 军事机构
- .net 网络服务提供商
- .edu 教育机构
6.lambda表达式
软件版本更新
加功能
改bug
加强安全
3.枚举
1.特有属性
默认继承类，所以只能实现接口
枚举类构造方法默认为私有方法。
枚举可以有属性，但是属性需要在构造方法中赋值
public class Demo4 {
public static void main(String[] args) {
Sex sex = Sex.woman;
//name为sex的名字，woman ordinal为位置，1
System.out.println(sex.name()+" "+sex.ordinal());
//相当于Sex.man
Sex sex2 = Sex.valueOf("man");
System.out.println(sex2.name()+" "+sex2.ordinal());
//输入枚举中的个数，2（只有women和man）
System.out.println(Sex.values().length);
}
}
enum Sex {
man("男人",1), woman("女人",2);
private int num;
private String name;
private Sex(String name , int num ){
this.name = name;
this.num = num;
}
@Override
public String toString() {
return "Sex{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
}
2.EnumSet
EnumSet<Season> enumSet = EnumSet.allOf(Season.class);
for (Season enum1 : enumSet) {
System.out.println("季节:"+enum1);
}
3.EnumMap
EnumMap<Season, String> map = new EnumMap<>(Season.class);
map.put(Season.SPRING, "春天");
map.put(Season.SUMMER, "夏天");
map.put(Season.FULL, "秋天");
map.put(Season.WINTER, "冬天");
Set<Season> set = map.keySet();
Iterator<Season> iterator = set.iterator();
while (iterator.hasNext()) {
Season season2 = (Season) iterator.next();
System.out.println("EnumMap:"+map.get(season2));
}
4.异常
1.分类：
- Error：错误
- Exception：运行中出现的不严重的错误
运行时异常：RuntimeException
编译时异常：
3.抛出异常、生成异常对象都可以通过 throw语句实现
Throws是声明异常
2.异常的抛出顺序：
从代码异常的地方依此上抛至jvm调用异常类打印
3.特点：
程序出现异常的时候,会打印异常的信息并中断程序,所以当有多个异常同时出现的时候,默认只能执行第一个.
4.try…catch
- 异常时try代码立刻中断，直接执行catch
- 无论完成与否，执行finally
- 注意：函数return时，finally仍然会执行，但是exit退出不会执行。
- catch捕捉的异常应该将子类放在前
5.自定义异常：
订单异常，用户异常，负数异常（一般直接继承Exception）
class FuShuException extends Exception{
public FuShuException() {
// TODO Auto-generated constructor stub
}
public FuShuException(String message) {
//这行代码必须写
super(message);
}
}
public class Demo6 {
public static void main(String[] args) //throws FuShuException
{
Math4 math4 = new Math4();
//第一种方式:继续向上抛,最后交给JVM
//math4.div(3, -2);
//第二种:tryCatch
try {
math4.div(3, -2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Math4{
//声明异常,告诉别人我是有可能发生这个异常.
//当需要声明多个异常的时候,直接用,隔开
public int div(int a,int b) throws FuShuException
{
if (b < 0) {
throw new FuShuException("除数为负数了");
}
return a/b;
}
}
来源：https://blog.csdn.net/qq_42326257/article/details/98766244