一、静态

1、构造函数：
      特点：
      1、 函数名和类名同样。
      2、 不用定义返回值类型（和void不是一回事，而构造函数是根本不用定义返回值类型）。
      3、 不能够写return语句。
      对象一建立就会调用与之相应的构造函数。
      构造函数的作用：能够用于给对象进行初始化。（我们现实生活中的事物，仅仅要一出现就具备的特性。

比方：人一出生就会哭，一初始化就会哭，哭就是这个人的行为）
      构造函数的小细节：
      1、当一个类中未定义构造函数时，那么系统会默认给该类增加一个空參数的构造函数。
      2、当在类中自己定义了构造函数后，默认的构造函数就没有了。 
      构造函数和一般函数在写法上有不同。
      在执行上也有不同：
      1、 构造函数是在对象一建立就执行。

给对象初始化。

            而一般方法是对象调用才运行。是给对象加入对象具备的功能。

      2、 一个对象建立。构造函数仅仅执行一次。
            而一般方法能够被对象调用多次。

    
      方法都是被对象调用（在没学静态之前） 
      什么时候定义构造函数呢：
      当分析事物时，该事物存在就具备一些特性或者行为。那么将这些内容定义在构造函数中。

2、主函数：public static void main(String[] args)  //arguments
     主函数是一个特殊的函数。作为程序的入口，能够被jvm调用。

     主函数的定义：
     public：代表着该函数訪问权限是最大的。

     static；代表主函数随着类的载入就已经存在了。

     void：对主函数没有详细的返回值。
     main：不是keyword，可是是一个特殊的单词，能够被jvm识别。
     (String[] arr)：函数的參数。參数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
     主函数是固定格式的：jvm识别。

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

class test
{
	public static void main(String[] args) //new String[] 
	{
		System.out.println(args);  //得[Ljava.lang.String;@1175422
		System.out.println(args.length);  //得0
	}
}

//args仅仅能接收两种值
//String[] args = new String[3];
//String[] args = null;

3、什么时候使用静态？
    要从双方面下手：
    由于静态修饰的内容有成员变量和成员函数。
    什么时候定义静态变量（类变量）：
    当对象中出现共享数据时，该数据被静态所修饰。
    对象中的特有数据要定义成非静态存在于堆内存中。
    什么时候定义静态函数：
    当功能内部没有訪问到非静态数据（对象的特有数据）。那么该功能能够定义成静态的。

4、静态的应用：
 每个应用程序中都有共性的功能，能够将这些功能进行抽取，独立封装，以便复用。
 尽管能够通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了些问题：
 1、对象是用于封装数据的。但是ArrayTool对象并未封装特有数据。
 2、操作数组的每个方法都没实用到ArrayTool对象中的特有数据。
 这时就考虑，让程序更严谨，是不须要对象的。能够将ArrayTool中的方法都定义成static的，直接通过类名调用就可以。
 将方法都静态后。能够方便于使用，可是该类还是能够被其它程序建立对象的。为了更为严谨，强制让该类不能建立对象。能够通过将构造函数私有化完毕，即private ArrayTool(){}

5、静态代码块
 格式：
 static
 {
  静态代码块中的运行语句。
 }
 特点：随着类的载入而运行，仅仅运行一次。

用于给类进行初始化的。

6、Person p = new Person("zhangsan", 20);
 该句话做了什么事情：
 1、由于new用到了Person.class，所以会先找到Person.class文件并载入到内存中。
 2、运行该类中的static代码块，假设有的话。给Person.class类进行初始化。
 3、在堆内存中开辟空间，分配内存地址。
 4、在堆内存中建立对象的特有属性，并进行默认初始化。
 5、对属性进行显示初始化。
 6、对对象进行构造代码块初始化。

 7、对对象进行相应的构造函数初始化。

 8、将内存地址赋给栈内存中的p变量。
 

7、设计模式：
 解决某一问题最行之有效的方法。
 java中23种设计模式：
 单例设计模式：解决一个类在内存中仅仅存在一个对象。
 想要保住对象唯一：
 1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
 2、还为了让其它程序能够訪问到该类对象。仅仅好在本类中，自己定义一个对象。
 3、为了方便其它程序对自己定义对象的訪问，能够对外提供一些訪问方式。
 这三步怎么用代码体现呢：
 1、将构造函数私有化。
 2、在类中创建一个本类对象。
 3、提供一个方法能够获取到该对象。
 对于事物该怎么描写叙述，还怎么描写叙述。当须要将该事物的对象保证在内存中唯一时。就将以上的三步加上就可以。
 饿汉式——懒汉试null（面试懒汉问得最多，问怎么解决这个问题。多线程也考到了synchronized。复合型比較高）
 记住原则：定义单例。建议使用饿汉式。
 

二、继承

1、继承概述：

代码：test.java

class Person
{
	String name;
	int age;
}

class Student extends Person
{
	void study(){}
}

class Worker extends Person
{
	void work(){}
}

class test
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.name = "zhangsan";
		System.out.println(s.name);  //得zhangsan   嘿，为啥子如今不用toString都能够正常输出了呀？
	}
}

代码：ExtendsDemo.java

class Person  //将学生和个人的共性描写叙述提取出来，单独进行描写叙述。仅仅要让学生和个人与单独描写叙述的这个类有关系(extends)。就能够了
{
	String name;
	int age;
}

	/*
	继承：
	1、提高了代码的复用性。

	2、让类与类之间产生了关系。
有了这个关系，才有了多态的特性。

	
	注意：千万不要为了获取其它类的功能，简化代码而继承。
必须是类与类之间有所属关系（Student is a Person.）才干够继承。

	举个样例：
	
	class C  //C是找到A和B的共性内容，抽取的
	{
		void demo1(){}
	}

	class A extends C
	{
		//void demo1(){}
		void demo2(){}
	}

	class B extends C
	{
		//void demo1(){}  //A和B里面都有demo1()，就如果B继承A，B就拿到了A的demo1方法。但同一时候也拿到了demo2()，思考B应该拿到demo2()吗。不应该。那么它们之间没有继承关系。
那他们确实有一样的demo1()呀，我们就加个C，去继承C。
		void demo3(){}
	}

	*/
class Student extends Person  
/*
keywordextends，就能够让学生和Person产生点关系。学生就是Person的子类，Person就是学生的子类。Person也叫做超类、基类。

Java语言中：java仅仅支持单继承，不支持多继承（即一个类能够继承多各类。这个说得不严谨）。
java不支持多继承的优点就是优化了C++的部分，由于C++支持。

比方：Student继承了Person类就不能继承其它类了

由于多继承easy带来安全隐患：
当多个父类中定义了同样功能，当功能内容不同一时候，子类对象不确定要执行哪一个。
可是java保留这样的机制，并用还有一种体现形式来完毕表示：多实现（java对多继承的改良）。


java支持多层继承（C继承B。B继承A 祖孙三代）。也就是一个继承体系。

怎样使用一个继承体系中的功能呢：
想要使用体系，先查阅体系父类的描写叙述，由于父类中定义的是该体系中的共性功能。
通过了解共性功能，就能够知道该体系的基本功能。
那么这个体系已经能够基本使用了。


那么在详细调用时，要创建最子类的对象。为什么呢：
一是有可能父类不能创建对象（比方抽象类），二是创建子类对象能够使用很多其它的功能，包含主要的也包含特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。


Class A
{
	void show()
	{
		System.out.println("a");
	}
}

Class B
{
	void show()
	{
		System.out.println("b");
	}
}

class C extends A, B
{}

C c = new extends A, B;
c.show();  //问：打印的是a还是b呀，是不是不确定呀。


*/
{
	void study()
	{
		System.out.println("good study");
	}
}

class Worker extends Person  
{								
	void work()
	{
		System.out.println("good work");
	}
}

class ExtendsDemo
{
	public static void main(String[] args)
	{
		Student s = new Student();
		s.name = "zhangsan";
	}
}

 对象与对象之间或者类与类之间或者说事物间不光继承这一种关系
 聚集：has a （一般用聚集关系比继承还要多）
 1、聚合：（球员是球队中的一个。球队中有球员）
 2、组合：事物间联系更紧密（手是人身体的一部分。心脏是人身体的一部分）

2、子父类中变量的特点：

代码：ExtendsDemo2.java

class Fu
{
	int num1 = 4;
}

class Zi extends Fu
{
	int num2 = 5;
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		System.out.println(z.num1 + "....." + z.num2);  //得4.....5
	}
}

代码：ExtendsDemo2.java

class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	int num = 5;
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		System.out.println(z.num + "....." + z.num);  //得5.....5  子类和父类的变量一样。调用子类的
	}
}

代码：ExtendsDemo2.java

class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	int num = 5;
	void show()
	{
		System.out.println(num);  //num前省略了this.（this表示本类对象的引用，訪问本类的成员变量和成员方法）
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();  //得5 
	}
}

 代码：ExtendsDemo2.java

class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	//int num = 5;  //假设把这句话注视掉
	void show()
	{
		System.out.println(num);  //这里就省略了super.
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();  //得4
	}
}

代码：ExtendsDemo2.java 

/*
子父类出现后，类成员的特点：

类中成员：
1、变量
2、函数
3、构造函数

1、变量
假设子类中出现非私有的同名成员变量时，
子类要訪问本类中的变量，用this
子类要訪问父类中的同名变量，用super

super的使用和this的使用差点儿一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

*/
class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	//int num = 5;  //假设把这句话注视掉
	void show()
	{
		System.out.println(this.num);  //这里加上this.   num还是4
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();  //得4
	}
} 

代码：ExtendsDemo2.java

class Fu
{
	private int num = 4;
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return this.num;
	}
}

class Zi extends Fu
{
	void show()
	{
		System.out.println(num);  //num私有化了，怎么訪问num呢？
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();
	}
}

3、子父类中函数的特点：

代码：ExtendsDemo3.java

class Fu
{
	void show1()
	{
		System.out.println("fu show");
	}
}

class Zi extends Fu
{
	void show2()
	{
		System.out.println("zi show");
	}
}

class ExtendsDemo3
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show1();  //得fu show
		z.show2();  //得zi show
	}
}