1.纯抽象类不能继承接口。
2.设计模式(战术)和架构模式(战略)
3.设计模式的选择依据其适用性和代码的美观程度。
4.架构分为 B/S和C/S
B/S的逻辑代码堆积在服务器上,客户端很轻,方便升级和修改。B/S适合于企业管理。
C/S的逻辑代码房子客户端,有一个庞大的客户机,减轻了服务器的压力。缺点是需要升级和下载,比较麻烦。C/S适合于运算(不需要服务器)。
5.简单工厂:工厂方法和抽象工厂的入门模式。
6.创建型设计模式(简单工厂)专门负责常见对象。
public interface SPY {
publicvoid 找钱();
publicvoid 查询();
publicvoid 出票();
}
class 张学友 implementsSPY{
public void 出票() {
System.out.println("张学友出票");
}
public void 找钱() {
System.out.println("张学友找钱");
}
public void 查询() {
System.out.println("张学友查询");
}
}
class 李宇春 implementsSPY{
public void 出票() {
System.out.println("李宇春出票");
}
public void 找钱() {
System.out.println("李宇春找钱");
}
public void 查询() {
System.out.println("李宇春查询");
}
}
class 成龙 implementsSPY{
public void 出票() {
System.out.println("成龙出票");
}
public void 找钱() {
System.out.println("成龙找钱");
}
public void 查询() {
System.out.println("成龙查询");
}
}
class 李四 implementsSPY{
public void 出票() {
System.out.println("李四出票");
}
public void 找钱() {
System.out.println("李四找钱");
}
public void 查询() {
System.out.println("李四查询");
}
}
class 李宇春2 extends 李宇春{
public void 找钱() {
System.out.println("李宇春准确找钱");
}
}
public interface 唱歌 {
public void 唱();
}
class 张学友2 extends 张学友 implements 唱歌{
public void 唱() {
System.out.println("张学友唱歌");
}
}
public class 工厂 {
public SPY create(String name){
if(name.equals("李宇春"))
{
return new 李宇春2();
}else
if(name.equals("成龙"))
{
return new 成龙();
}else
if(name.equals("张学友"))
{
return new 张学友2();
}else
return null;
}}
public class Test1 {
publicstatic void main(String[] as){
工厂 m=new 工厂();
SPY s=m.create("张学友");
s.出票();
s.找钱();
s.查询();
唱歌 c=(唱歌)s;
c.唱();
工厂 n=new 工厂();
SPY a=n.create("李宇春");
a.出票();
a.找钱();
a.查询();
}
}
7.单态(又叫单例,单个对象,单个实例)属于创建型设计模式,让一个类只出一个对象。保证一个类只出一个对象的方法:将构造器便成为私有的 private Dog(){}
8.单态分为饿汉式单态和懒汉式单态
9. 饿汉试模式:提前构造对象。
优点:速度快;缺点:提前加载资源,有可能会浪费资源
public class Dog {
privateDog(){
}
//private static Dog d=new Dog();
privatestatic Dog d;//提前加载资源
{
d=new Dog();
}
public static DoggetDog(){
return d;
}
}
10.懒汉式模式:什么时候用,什么时候构造对象。
优点:不提前噪声资源的浪费;缺点:访问速度慢。
懒汉模式是不安全的单例,在多用户下出多个对象。
public class Dog1 {
private static Dog1 d;
public static synchronized Dog1 getDog1(){ //synchronized表示今后执行此方法时必须排列执行
if(d==null){ //什么时候用什么时候构造对象,没有的话再构造对象
d=newDog1();
}
return d;
}
}
11.同类名直接访问的是静态属性 System.out.println();
类 静态属性
12.用单例的条件:
想要让一些类只出一个对象,必须用单例。
‚类的访问次数过高,但类又不作任何信息记载,用单例。
嵌套类
1. 内部类看成属性。
2. 对象.静态方法或静态属性或者实例
3. 如果内部类是静态的,则只能访问外部类的静态属性;如果内部类是实例的,则可以访问外部类的实例方法和实例属性。
私有的内部属性只能自己使用。
4.public class 帽子 {
privatestatic String[] tName = {"白兔","黑兔","流氓兔","灰兔", "呕兔" };
private兔子[] ts = null;
privateString hatName;
class兔子 {
privateString name;
public兔子(String name) {
this.name= name;
}
publicString toString() {
returnname;
}
}
public帽子(String name) {
hatName= name;
ts= new 兔子[(int) (Math.random() *100)+1];
for(int i = 0; i < ts.length; i++) {
ts[i]= new 兔子(tName[(int) (Math.random()* 5)]);
}
}
publicString toString() {
Stringtxt = "帽子:" +hatName + " 开始跳!\n";
for(兔子 t : ts) {
txt= txt + t + "\t";
}
txt= txt + "\n";
returntxt;
}
}
public class 表演魔术 {
publicstatic void main(String[] args) {
帽子 m1 = new 帽子("红帽子");
帽子 m2 = new 帽子("灰帽子");
帽子 m3 = new 帽子("蓝帽子");
System.out.println(m1);
System.out.println(m2);
System.out.println(m3);
}
}
匿名内部类
public interface H{
publicvoid method();
}
public class Test1{
finalString name=”lise”;
Hh=new H(){ //无名内部类
public void method(){
System.out.println(name);
}
};
h.method();
new H(){
public void method(){
System.out.println(name);
}
}.method();
}
}