1：单例模式：对象有且只有一个。
#外部无法访问到对象===构造器私有。
#在本类中，声明自己类型的变量，作为本身属性--->私有。
#在本类中，设置静态方法，以返回值（返回本类类型）获取对象。
单例模式得到对象后，可以调用类中的其他任何方法，进行使用！
//单例模式------饿汉模式(实际开发要经常用)
/*
public class Sun {
private static Sun sun=new Sun();
private Sun(){
}
public static Sun getSun(){
return sun;
}
}
//单例----懒汉模式(面试要用 ) 单例模式是干嘛的? 解决什么问题? 用代码实现
//懒汉模式容易出现线程安全问题
public class Sun{
private static Sun sun;
private Sun(){
}
public static Sun getSun(){
if(sun==null){
sun=new Sun();
}
return sun;
}
}
2：模板模式：
父类/父接口====提供一个模板，提供一个模板方法（操作程序流程的方法）。
public abstract class Person {抽象类
public abstract void eat();
public abstract void play();
public abstract void sleep();
public void show(){
eat();
play();
sleep();
}
public static void go(Person d){
d.show();
模板方法
}
}
public interface Person {接口
void eat();
void play();
void sleep();
默认方法
public default void show(){
eat();
play();
sleep();
}静态方法
public static void go(Person p){
p.show();模板方法
}
}
public class Test1 {
public static void main(String[] args) {
Person.go(new Person() {
匿名内部类
public void sleep() {
}
public void play() {
}
public void eat() {
}
});
}
}
public class Test {
public static void main(String[] args) {
Person.go(new Person() {
匿名内部类
public void sleep() {
}
public void play() {
}
public void eat() {
}
});
}
}
3:装饰者模式！==解决类爆炸问题！类的臃肿问题！
1；提供一个模板接口或抽象类，再对其实现类和子类进行实例化结束后，还想对其进行功能的添加，而又不破坏原有的实例化类，，可以自定义一个装饰类，保存原有的功能，在添加自己特有的功能！！
2：自定义高级流（所有的高级流都是利用了装饰者模式=在原有低级流的基础上，增加自己的特殊高端的读取和写出数据的功能！低级流的所有功能高级流均可使用，是不改动低级流的基础上，利用第三方来扩充低级流的功能！）
3：自定义面板划线
4：聊天室====封装的Socket对象==装饰者的体现！
package demo1;
import java.io.IOException;
import java.io.Reader;
public class MBufferedInputStream {
private Reader reader;
public MBufferedInputStream(Reader reader) {
super();
this.reader = reader;
}
public String readLine() throws Exception{
StringBuilder str=new StringBuilder();
int num;
while((num=reader.read())!=-1){
if(num=='\r'){
continue;
}
if(num=='\n'){
break;
}
}
if(num==-1){
return null;
}
return str.toString();
}
public void close(){
try {
reader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4：代理模式！
1：代理模式===典型==实现Runnable接口，再通过Tread类的构造器。
2：代理类===抽象角色---真实角色--代理角色！
3：
通过操作代理类，从而得到原本类的功能，而不直接操作其根类！
在代理类中通过构造器赋值真实角色，不直接操作真实角色，而是通过构造方法得到其功能，从而可以自我优化！
package demo;
public interface Person {
public abstract void createMan();
}
class China implements Person {
@Override
public void createMan() {
System.out.println("本土造人哦哦！");
System.out.println("造人！！");
System.out.println("生产人哦！");
}
}
class DaiLi{
China ch;
public DaiLi(China ch){
this.ch=ch;
}
public void sell(){
ch.createMan();
System.out.println("买一送一哦！");
}
}
5；MVC模式：
1：dao层；
包括实体类和对实体类数据的封装方法和处理的方法！提供一个模板接口或抽象类。
2：业务逻辑层；
在底层数据和外部界面之间的调度！
3：ui层：
对界面的处理和优化；
6：工厂设计模式：====降低程序的耦合度！
1：面向抽象原则：声明多用接口和抽象类！
2：开闭原则：对扩展开放，对修改封闭！
3：多用组合，少用继承！
4；高内聚，低耦合！内聚---一个类尽可能多的独立完成一类的功能，尽量不去过分的依赖其他类来完成相应的功能
5：
package demo;
public interface Factory {
public abstract void create();
}
class Phone implements Factory{
@Override
public void create() {
System.out.println("生产手机");
}
}
class IceBox implements Factory{
@Override
public void create() {
System.out.println("生产冰箱");
}
}
class NoteBook implements Factory{
@Override
public void create() {
System.out.println("生产笔记本！");
}
}
package demo1;
//工厂方法！
public interface Factory {
//通过 带有返回值的方法！
public abstract Factory create();
}
//通过实现抽象方法，返回相应的实现类对象！
class Phone implements Factory{
@Override
public Factory create() {
System.out.println("生产手机");
return new Phone();
}
}
class IceBox implements Factory{
@Override
public Factory create() {
System.out.println("生产冰箱");
return new IceBox();
}
}
class NoteBook implements Factory{
@Override
public Factory create() {
System.out.println("生产笔记本！");
return new NoteBook();
}
}
package demo;
public class SuperMarket {
// 工厂模式-
--静态方法=
// 通过全局常量====传入对象名==作为比较的对象！
public static final String STR = "手机";
public static Factory get(String str) {
if ("手机".equals(str)) {
return new Phone();
}
if ("笔记本".equals(str)) {
return new NoteBook();
}
if ("冰箱".equals(str)) {
return new IceBox();
}
return null;
}
}
package demo1;
public class Test {
public static void main(String[] args) {
Factory f=new NoteBook();
f.create();
}
}
package demo;
public class Test {
public static void main(String[] args) {
// Factory ff=SuperMarket.get("手机");
// ff.create();
Factory ff=SuperMarket.get(SuperMarket.STR);
ff.create();
}
}
7: 线程通讯:==生产消费模式！
* 生产的实体=
* 生产者 消费者 有产品则不生产 去销售
* 没有产品就生产 不去销售
*
*
* 生产完----消费 消费完----生产
*
*
* 线程通讯的方法是通过锁对象调用======因为两个线程之间关联是锁对象
* 通讯的方法在在Object里面 类里面定义的！ 因为锁对象可以是任意类型的对象
*
*
* wait() 让当前线程处于等待状态
* notify(),唤醒正在等待的其他线程中的随机一个
* notifyAll() 唤醒正在等待的其他线程所有
* 如果线程处于等待并且没有其他线程进行唤醒,则就是死锁状态
@Override
public void run() {
while (true) {
synchronized (per) {
//通过boolean 来判断是否进行等待！
if (per.flag) {
try {
// wait方法必须写在同步代码块里面哦！
/*
* 当线程处于等待状态时，会自动释放锁！（把锁的使用权移交出去！）
*
* 线程存在记忆，再次获取锁的使用权后，从上次等待的地方从新开始启动线程！
*/
per.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (i % 2 == 0) {
per.name = "步惊云";
per.age = 22;
} else {
per.name = "聂风";
per.age = 11111;
}
i++;
// 生产完表示有货！
per.flag = true;
// 唤醒其他的即为消费的线程！
per.notify();
}
16万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
