1、构造代码块是给所有的对象进行初始化；

     构造函数是给对应的对象初始化；

2、当在类中自定义了构造函数后，默认的构造函数就没有了；

    构造函数是在对象一建立就运行，给对象初始化；

    而一般的方法是在对象调用才执行，给对象添加对象具备的功能；

    一个对象建立，构造函数只运行一次；而一般方法可以被该对象调用多次；

3、public static void main(String[] args)   args 是可以改的
        主函数：特殊的函数、程序入口，可被jvm调用
        public :代表访问权限最大；
        static： 代表主函数随着类的加载就已经存在了；
        void ： 主函数没有具体访问值；
        main：不知关键字；可被jvm识别；
        (String[] arr) : 函数的参数，类型为数组，该数组中的元素是字符串，字符串类型的数组；
        主函数是固定格式的：jvm识别。

        jvm在调用主函数时，传入的是new String[0];

4、单例设计模式：解决一个类在内存中只存在一个对象。

    想要保证对象唯一；
    1、为了避免其他程序过多建立该类对象。先禁止其他程序建立对象；
    2、还为了让其他程序访问到该类程序，只好在本类中自定义一个对象；
    3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

    代码体现：
    1、将构造函数私有化；
    2、在类中创建一个本类对象；

    3、提供一个方法可以获取到该对象。

    当需要将该事物的对象保证在内存中的唯一时，加上以上三步即可。

5、记住原则：定义单例时，建议使用饿汉式.

    先初始化对象；Single类一进内存就已经创建好了对象。

    懒汉式：对象是方法被调用时，才初始化，也叫做独对象的延时加载，什么时候需要，什么时候创建对象。
Single类进内存时，对象还没有存在，只有调用了getinstance方法时，才建立对象。

class Single
{
	private static Single s = new Single();
	private Single(){};

	public static Single getInstance()
	{
		return s;
	}
}

懒汉式的优化，加快效率：
class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()  //sy
	{
		if (s==null)
		{
			synchronized(Single.class)  //synchronized 相当于给门上了把锁，三个方法ABC,A在里面，则B进不来，A新建对象，出去后，B再进来，此时已有对象，直接返回s，C不为空，第一次判断null时就进不来 
			{
				if (s==null)
					s = new Single();
			}	
		}
		return s;
	}
}

6、静态

（1）什么时候使用静态？

    当功能内部没有访问到非静态数据（对象的特有数据），该功能可以被定义为非静态。

static特点：
1、随着类的加载而加载；也就说静态会随着类的消失而消失，说明它的生命周期最长。
2、优先于对象存在；明确：静态是先存在，对象是后存在的。
3、被所有对象所共享；
4、可以直接被类名所调用。

实例变量和类变量的区别：
1、存放位置
    类变量随着类的加载而存在于方法区（也就是共享区）中，
    实例变量随着对象的建立而存在堆内存中。
2、生命周期
    类变量生命周期最长，随着类的消失而消失，
    实例变量生命周期随着对象的消失而消失。

/*
静态代码块：
static
{
	执行语句；
}
特点：随着类的加载而加载，只执行一次,无需调用。并优先于主函数。
用于给类进行初始化。
注意：代码块的执行顺序。
*/
class StaticCode
{
    int num =9;
    String name; //非静态变量；成员变量，实例变量
    static String country ="cn; //静态的成员变量、类变量
    StaticCode()
    {
        System.out.println("b");
    }

    static
    {
        System.out.println("a"); //静态代码块，给类初始化的
    }
    {
        System.out.println("c"+this.name); // 构造代码块，给对象初始化的
    }

    StaticCode(int x)
    {
        System.out.println("d");//构造函数，给对应对象初始化的
    }

    public static void show()
    {
        System.out.println("show run");
    }
}

class StaticCodeDemo
{
    static
    {
        //System.out.println("b");
    }

    public static void main(String[] args)
    {
        //new StaticCode();
        //new StaticCode(); //StaticCode类已经存在，static已经被执行一次了，不再执行。
        new StaticCode(4); //e a c9 d
    }
    static
    {
        System.out.println("e");
    }
}
//output: e a cnull d

7、抽象

    典型的抽象类是模板模式（11条），只定义确定的部分，将不确定的部分暴露出去（如员工和经理都有工资，但经理还有分红，见第8条继承中的eg）。

1.抽象类不能被实例化。
2.抽象类可以有构造函数，被继承时子类必须继承父类一个构造方法，抽象方法不能被声明为静态。
3.抽象方法只需申明，而无需实现，抽象类中可以允许普通方法有主体
4.含有抽象方法的类必须申明为抽象类
5.抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类。

/*
当多个类中出现相同功能，但是功能主体不同，
这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。

抽象：看不懂。
抽象类特点：
1、抽象方法一定定义放在抽象类中；
2、抽象方法和抽象类都必须被abstract关键字修饰；
3、抽象类不可以被new创建对象，因为调用抽象方法没意义。
4、抽象类中的抽象方法要被使用，需要由子类复写所有的抽象方法后，建立子类对象调用。
	如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
	父类只定义功能(需求),由子类去完成。

抽象类和一般类没有太大的不同。
该如何描述事物就如何描述。只不过该事物中出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体，
通过抽象方法来表示。

抽象类比一般类多了抽象函数，在类中可以定义抽象方法
只定义类和方法；抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

8、继承 

    通俗地讲，继承就是从很多对象中抽取出共有属性。把共同的操作写成一个父类，然后让子类去继承它，那么我们就不用在写相同的代码了。

将学生和工人的共性描述提取出来，单独进行描述，
只要将两者与单独描述的这个类有关系，就可以了。

继承：extends
1、提高代码的复用性；
2、让类与类之间产生关系，有了这个关系，才有了多态的特性。

子类继承父类中的功能。子类应具备父类中的所有功能，才能去继承

eg:开发系统时需对员工建模，员工包含三个属性：姓名、工号、工资，
经理也是员工，除了含员工的属性外，还有奖金属性，
请使用继承的思想设计出员工类和经理类，要求类中提供必要的方法进行属性访问。

员工类： name，id，pay
经理，除了上面三个，还有自己的bonus
*/

abstract class Employee
{
	private String name;
	private String id;
	private double pay;

	Employee(String name,String id,double pay)  //确定的部分
	{
		this.name=name;
		this.id=id;
		this.pay=pay;
	}
	public abstract void work();//抽取功能定义  不确定的部分
} 

class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay)
	{
		super(name,id,pay);  //继承父类
		this.bonus=bonus;
	}
	public void work()
	{
		System.out.println("manager work");
	}
}

9、final

/*
final:最终，作为一个修饰符；
1、可以修饰类、函数、变量。
2、被final修饰的类不可以被继承。为了避免被继承，被子类复写功能
3、被final修饰的方法不会被复写。
4、被final修饰的变量是一个常量只能复制一次，既可以修饰成员变量，也可以修饰局部变量。
	当描述事物时，一些数据的出现值是固定的，那么为增加阅读星，都给这些变量起个名字以便阅读；
	当这个值不需要改变时，再加上final修饰。作为常量，常量的书写规范是所有字母都大写，多个单词间则通过下划线连接。
5、内部类定义在类中的局部位置上，只能访问该局部被final修饰的局部变量。
*/

class Demo
{
	final int x =3;
	public static final double PAI =3.14；//将PAI的值固定,加static则可共享，public赋权限，但值不会变
	final void show1()
	{}
		void show2()
	{
		final int y=4;
		System.out.println(3.14);
	}
}

public interface DBUtil {
    public void openConnection();
    public List findData(String hql );
    public void closeConnection;
}

    抽象类是为继承而精心设计的，接口则更多以组合的方式使用。

/*
接口：初期理解：可以认为是一个特殊的抽象类
	当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口

接口定义时，格式特点：
1、接口中常见定义：常量、抽象方法
	常量：public、static、final
	方法： public、abstract
记住：接口中的成员都是public的。

接口： 是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。

*/

interface Inter
{
    public static final int NUM = 3;
    public abstract void show();
}
interface InterA
{
    public abstract  void method();
}
interface InterC extends Inter,InterA
{
    void methodC();
}
class Demo
{
    public void function(){};
}
class Test extends Demo implements Inter,InterA  //Test继承Demo，又实现两个接口
{
    public void show(){};
    public void method(){};
}

public class InterfaceDemo
{
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println(t.NUM);   // 3
        System.out.println(Test.NUM);  // 3
        System.out.println(Inter.NUM);  // 3
    }
}

11、模板设计方法

    典型的抽象类，将不确定的部分暴露出去

/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。 

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模板方法设计模式。

什么是模板设计方法？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去，由该类的子类去完成。

提高扩展性、复用性。
*/

abstract class GetTime
{
	public final void getTime()  //写final，强制性避免覆盖
	{
		long start = System.currentTimeMillis();
		
		runcode();

		long end  = System.currentTimeMillis();
		System.out.println("毫秒："+(end-start));
	}
	public abstract void runcode();

}

class SubTime extends GetTime
{		
	public void runcode()
	{
		for (int x=0;x<4000 ;x++ )
		{
			System.out.print(x);
		}
	}
}

class  TemplateDemo
{
	public static void main(String[] args) 
	{
		//GetTime gt = new GetTime();
		GetTime gt = new SubTime();
		gt.getTime();
	}
}

12、多态

     cat，是猫科，也是动物，这就是多态。多态，可以理解为事物的多种体现形态。用多态，可以只调用共有属性eat()，也可强制转换后调用独有属性catchMouse()。

abstract class Animal
{
    public abstract void eat();
}

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("eat fish");
    }
    public void catchMouse()
    {
        System.out.println("catch mouse");
    }
}

public class DuotaiDemo {
    public static void main(String[] args)
    {
//        Cat c = new Cat();
//        c.eat();
//        c.catchMouse();
        Animal a = new Cat(); //类型提升，向上转型，不能向下
        a.eat();  //此时只有eat()方法，没有catchMouse()方法
//        function(new Cat());
    }
    //先调用父类功能，子类去实现，并把子类参数传进去
    public static void function(Animal a)
    {
        a.eat();
        if (a instanceof Cat)  // instanceof 用来判断所属类型
        {
            //调用Cat的特有属性，强制将父类的引用转换为子类型
            Cat c = (Cat)a;
            c.catchMouse();
        }
    }
}

13、Object

    Object类是Java中唯一没有父类的类。其他所有的类，包括标准容器类，比如数组，都继承了Object类中的方法。