class PersonDemo{
private String name;
{
System.out.println("this is construct code block !");
}
PersonDemo(){
this.name="zhangsan";
}
PersonDemo(String name){
this.name=name;
}
public void say(){
System.out.println("name :"+this.name);
}
}
public void onClick(View v) {
new Thread() {
@Override
public void run() {
}
}.start();
}
class Outer{
private int x;
public Outer(int x) {
this.x = x;
}
class Inner{
public void method(){
System.out.println(x);
System.out.println(Outer.this.x);
}
}
public void getInner(){
Inner in=new Inner();
in.method();
}
}
主函数是一个特殊的函数,作为程序的入口,可被jvm调用 public:代表访问权限是最大的 static:代表主函数是独立于类存在的,并且该函数是在类的加载的时候被加载 void:不用呗jvm返回一个参数 String[] args :jvm需要的参数
注意这个main函数除了args是可以改的以外其他都不可改,不然不可以被jvm识别 同时main是可以被重载的,但是只有仅仅满足以上格式的才能被jvm执行, string[] 这个参数其实就是命令行传的参数
//静态代码块
static {
//static code block
}
单例设计模式一般来说就有两种方式,一个是懒汉式,一个是饿汉式。其中懒汉式使用的类的延时加载,但是会出现安全问题,需要使用同步代码块包裹返回的对象,并且做双重判断才可以。
package learn;
/**
* 单例模式的第一种实现方式,也是最常用的一种叫做饿汉式
* 他是先初始化对象
*/
class SingleHunger{
private String name;
private int age;
private static SingleHunger s=new SingleHunger("lwen",19);
private SingleHunger(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static SingleHunger getSingle() {
return s;
}
}
/**
* 这个又成为懒汉式也叫做对象的延时加载,他则使用的比较少,因为在进行new新对象的时候可能会有两个线程同时进入临界区导致对相爱那个不唯一
* 多一需要做同步操作,但是同步的时候又会消耗时间,下面的方式要稍微好一点一般只做了一次同步操作,还有一种解决方案就是直接在class后面添加同步关键字
* 每次都要判断非常耗时
*/
class SingleLazy{
private String name;
private int age;
private static SingleLazy s=null;
/**
* 使用private限定词是为了防止外部的方法直接调用本类中的构造方法生成新的对象
* @param name
* @param age
*/
private SingleLazy(String name,int age){
this.age=age;
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static SingleLazy getSingle(){
/*
同步机制加双重判断,防止意外情况发生
*/
if (s==null){
synchronized (SingleLazy.class){
if (s==null) {
s = new SingleLazy("lwen", 19);
}
}
}
return s;
}
}
public class SingleModel {
public static void main(String[] args){
SingleHunger s1=SingleHunger.getSingle();
s1.setAge(20);
s1.setName("lwenxu");
SingleHunger s2=SingleHunger.getSingle();
System.out.println(s2.getName());
}
}
模板设计模式,就是在一段确定的方法中调用了一些不确定的方法。那么就把这些不确定的方法定义成抽象的方法,并且把这些不确定的方法的接口给暴露出去
abstract class codeTime{
final public long getTime(){
long start=System.currentTimeMillis();
runCode();
long end=System.currentTimeMillis();
return end-start;
}
abstract void runCode();
}
class ACodeTime extends codeTime{
void runCode(){
for (int i=0;i<1000;i++){
System.out.println(i);
}
}
}
public class Template {
public static void main(String[] args) {
ACodeTime time=new ACodeTime();
System.out.println("time is :"+time.getTime());
}
}