轻烟薄雾} }
class Circle{ private double radius;
private static String info = \我是一个圆\private int id;//编号
private static int init = 1001;//控制每个对象的id private static int total = 0;//记录创建了多少个对象
public Circle(){ this.id = init++; total++; }
public Circle(double radius){ this.radius = radius; this.id = init++; total++; }
public double getRadius() { return radius; }
public void setRadius(double radius) { this.radius = radius; }
public static String getInfo() { return info; }
public static void setInfo(String info) { Circle.info = info; }
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public static int getTotal() { return total; }
public static void setTotal(int total) { Circle.total = total; }
@Override
public String toString() { return \
}
}
public static void show(){ System.out.println(Circle.info); }
public void desc(){ System.out.println(this.info); }
单例模式
23种设计模式
单例模式：
解决的问题：如何只让设计的类只能创建一个对象 如何实现：饿汉式 & 懒汉式 //饿汉式1 class Bank{
//1.私有化构造器 private Bank(){}
//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性 //4.要求此对象也为static的 private static Bank instance = new Bank(); //3.此公共的方法，必须为static public static Bank getInstance(){ return instance; } }
//饿汉式2 class Bank{ //1.私有化构造器 private Bank(){} //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性 //4.要求此对象也为static的 private static Bank instance = null; static{ instance = new Bank(); } //3.此公共的方法，必须为static public static Bank getInstance(){ return instance; } }
//懒汉式 class Bank{ private Bank(){}
}
private static Bank instance = null;
public static Bank getInstance(){ }
if(instance == null){//可能存在线程安全问题的！ instance = new Bank(); }
return instance;
2.main()方法
public static void main(String[] args){ //方法体 }
//1.main()是一个方法，是主方法，为程序的入口
//2.权限修饰符：public protected 缺省 private ---面向对象的封装性 //3.对于方法来讲：static final abstract
//4.方法的返回值：void / 具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return
//5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意
//6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。 形参 & 实参---方法的参数传递机制：值传递
//7.方法体：方法定义的是一种功能，具体的实现由方法体操作。 3.代码块
代码块：是类的第4个成员 作用：用来初始化类的属性 分类：只能用static来修饰。
* 静态代码块：
* 1.里面可以有输出语句
* 2.随着类的加载而加载，而且只被加载一次 * 3.多个静态代码块之间按照顺序结构执行
* 4.静态代码块的执行要早于非静态代码块的执行。
* 5.静态的代码块中只能执行静态的结构(类属性，类方法) *
* 非静态代码块：
* 1.可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
* 2.里面可以有输出语句
* 3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行 * 4.每创建一个类的对象，非静态代码块就加载一次。 * 5.非静态代码块的执行要早于构造器 *
* 关于属性赋值的操作： ①默认的初始化
②显式的初始化或代码块初始化(此处两个结构按照顺序执行) ③构造器中；
—————————以上是对象的属性初始化的过程—————————————
④通过方法对对象的相应属性进行修改 4.final关键字
/*
* final:最终的 ，可以用来修饰类、属性、方法 *
* 1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类 *
* 2.final修饰方法：不能被重写。如：Object类的getClass() *
* 3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。 * 此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。 *
* 变量用static final修饰：全局常量。比如：Math 类的PI *
* >与finally finalize()区分开 * */
class D{ final int I = 12; final double PI; final String NAME; public void m1(){ System.out.println(I); // I = 10; } { PI = 3.14; } public D(){ NAME = \ } public D(String name){ this(); //NAME = name; } }
5.抽象：abstract
重点！
abstract：抽象的，可以用来修饰类、方法
* 1.abstract修饰类：抽象类 * 1)不可被实例化
* 2)抽象类有构造器 (凡是类都有构造器) * 3)抽象方法所在的类，一定是抽象类。
* 4)抽象类中可以没有抽象方法。
* >当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化
* * 2.abstract修饰方法：抽象方法
* 1)格式：没有方法体，包括{}.如：public abstract void eat();
* 2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。 * 3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个\实体类\即可以实例化
* 4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！
模板方法的设计模式
//模板方法设计模式 public class TestTemplate { public static void main(String[] args) { new SubTemplate().spendTime(); } }
abstract class Template { public abstract void code(); public void spendTime() { long start = System.currentTimeMillis(); this.code(); long end = System.currentTimeMillis(); System.out.println(\花费的时间为：\ } }
class SubTemplate extends Template { public void code() { boolean flag = false; for(int i = 2;i <= 10000;i++){ for(int j = 2;j <= Math.sqrt(i);j++){ if(i % j == 0){ flag = true; break; } } if(!flag){ System.out.println(i); } flag = false; } }
