一、静态
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
}
}