【www.bbyears.com--Java基础】
01.面向对象（static关键字）
用法：是一个修饰符，用于修饰成员（成员变量和成员函数）。
当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用之外，还可以被类名直接调用。类名.静态成员。
对象的特有内容随着对象存储，共有内容可以定义为静态的，放在共享区。
类中的方法区，共享区，数据区都在同一个区。
static的特点：
（1）随着类的加载而加载，随着类的消失而消失。也就是说，静态会随着类的消失而消失，说明他的生命周期最长。
（2）优先于对象存在；明确一点：静态先存在，对象后存在。
（3）被所有对象所共享；
（4）可以直接被类名调用。
实例变量和类变量的区别：
（1）存放位置：类变量随着类的加载而存在与方法区中；实例变量随着对象的建立而存在于堆内存中。
（2）生命周期：类变量的生命周期最长，随着类的消失而消失；实例变量的生命周期随着对象的消失而消失。
静态的使用注意事项：
（1）静态方法只能访问静态成员和静态方法。因为静态方法和变量在类加载时就在了，非静态变量在对象存在时才存在
（2）非静态方法可以访问静态也可以访问非静态。
（3）静态方法中不可以定义this，super关键字。因为静态优先于对象存在，所以静态方法不可以出现this。
（4）主函数是静态的。
静态有利有弊：
利：对对象的共享数据进行单独空间的存储，节省空间的内存，没有必要每个对象都存储一份；可以直接被类名调用。
弊：生命周期过长，访问出现局限性，静态虽好只能访问静态。
02.面向对象（主函数main）
主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表着主函数随着类的加载就已经存在。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
函数的参数（String[] args）：参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。
jvm在调用主函数时，传入的是new String[0];
启动jav虚拟机，并为主函数传参数：java TestMain haha heiehi
这说明java虚拟机在执行TestMain时给主函数传入了haha和嘿嘿两个参数。
还可以用下面的方法：
{
public static void mian(String[] args)
{
String[] arr={"1","2","3"};
Maintest(arr);
}
}
class Maintest
{
public static void main(String[] args)
{
for(int i=0;i {
System.out.println(args[i]);
}
}
}
03.面向对象（什么时候使用静态）
要从两方面下手：
因为静态修饰的内容是成员变量和函数。
什么时候定义静态变量（类变量）呢？
当对象中出现共享数据时，该数据被静态所修饰；对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以被定义成静态的。
04.面向对象（静态的应用--工具类）
每个应用程序中都有共性的功能，可以将这些功能进行抽取，进行封装。
当考虑让程序更严谨时，如果不需要对象，可以将一个类中的成员设为静态的，直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的，为了更严谨，应该强制该类不能建立对象，可以将构造函数私有化就不允许建立对象了。
05.面向对象（帮助文档的制作）
java的说明书通过文档注释来完成。
格式：
/**
功能说明语句
@author 作者
@version 版本
@param 参数
@return 返回值
*/
每个类和凡是用public修饰的成员函数都要用文档注释给说明。
给一个类生成文档：
javadoc -d 目录（路径） -author -version
给一个类生成文档，该类必须是public的
一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。
如果被public修饰，那么默认的构造函数也带public修饰符。
如果类没有被public修饰，那么默认的构造函数，也没有public修饰符。
默认的构造函数的权限是随着所属类的变化而变化。
06.面向对象（静态代码块）
static
{
静态代码块的执行语句;
}
特点：随着类的加载而执行，只执行一次用于给类进行初始化的。在主函数前的静态代码块优先于主函数执行。
当一个类被new一个对象时，类中的构造代码块，静态代码块，构造函数执行顺序是：静态代码块，构造代码块，构造函数。
静态代码块随着类的加载而加载，只能调用静态成员。
07.面向对象（对象的初始化过程）
加载“类.class”文件；静态代码块执行（没有就不执行）；构造代码块初始化；构造函数初始化；
Person p=new Person（“张三”，20）;
这一句话所做的事：
1.因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。
2.执行该类中的静态代码块，如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性，并进行默认初始化。
5.对属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8.将内存地址赋给栈内存中的变量。
08.面向对象（对象调用成员过程）
09.面向对象（单例设计模式）
设计模式：java中有23中设计模式。
解决某一类问题最行之有效的方法。
单例设计模式：解决一个类在内存中只存在一个对象。
想要保证对象唯一：
（1）为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
（2）还为了让其它程序可以访问到该类对象，只好在本类中自定义一个对象。
（3）为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三部怎么体现：
（1）将构造函数私有化
（2）在类中创建一个本类对象，
（3）提供一个方法可以获取到该类对象。
{
private Single(){}
private static Single s=new Single();
public Static Single getInstance()
{
return s;
}
}
在类外，用Single s=Single.getInstance();访问。
对于事物该怎么描述，还怎么描述。
需要将该事物的对象保存在内存中唯一时，只要加上面三步就行。
10.面向对象（单例设计模式2）
单例设计模式的第二种写法：
代码如下 class Single{
private static Single s=null;
private Single(){}
public static synchronized Single getInstance()
{
if(s==null)
s=new Single();
return s;
}
}
第一种模式是先初始化对象，称为饿汉式。
特点：Single类一进内存，就已经创建好了对象。饿了就做。
搞开发时一般用饿汉式。
第二种方式调用时才被初始化，称为懒汉式。
特点：Single类进内存，对象还没有存在，只有调用了getInstance()方法时，才建立对象。刚开始时不做，什么时候需要什么时候做。
synchronized是给该方法上锁，当有一个对象操作该方法时，别的对象就不能操作。是为了防止两个对象同时操作该方法。
懒汉式最终解决方案：
{
private static Single s=null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized（Single.class）
{
if(s==null)
{
s=new Single();
}
}
}
return s;
}
}
记住原则：定义单例，建议使用饿汉式。
01.面向对象（继承-概述）
继承：提高了代码的复用性；让类与类之间产生了关系，才有了多态的特性。
注意：千万不要为了获取其它类的功能简化代码而继承，必须是有类与类之间有所属关系才可以继承，所属关系is a。
02.面向对象（继承-概述）
java语言中只支持单继承，不支持多继承。因为多继承容易带来安全隐患。
当多个父类中定义了相同功能时，当功能内容不同时，子类的对象不确定运行哪一个。
但是java保留了这种机制，并用了另一种体现形式来完成表示，多实现。
java支持多层继承。也就是一个继承体系。
如何使用一个集成体系中的功能呢？
想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中共性的功能，通过了解共性功能，那么这个体系已经可以基本使用了。
那么在具体使用时，要创建最子类的对象，为什么呢？一是因为有可能父类不能创建对象。二是创建子类对象可以使用更多的功能，包括基本的，也包括特有的。
简单一句话：查询父类功能，创建子类对象使用功能。
03.面向对象（聚集关系）
聚集：has a；分聚合和组合。
04.面向对象（子父类中变量的特点）
类中成员：
变量，函数，构造函数。
变量：如果子父类中出现了非私有的同名变量时，子类要访问本类中的变量，用this。；子类要访问父类中的同名变量，用super。
this代表本类对象的引用，super代表父类对象的引用。
05.面向对象（子父类中函数的特点）
子父类中函数的特点：
当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）。
当子类继承了父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这是，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。静态只能覆盖静态。
权限：啥修饰符都没有称为默认权限，介于共有和私有之间。
记住：
重载只看同名函数的参数列表，重写是字父类方法要一摸一样。
06.面向对象（子父类中构函数的特点-子类实例化过程）
子父类中构造函数的特点：
子类的构造函数的第一行隐式有一行语句：super();
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式语句super();
super();会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数：因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先看父类是如何对这些数据进行初始化的，所以子类在对象初始化时要先访问以下父类的构造函数，如果要访问父类中指定的构造函数，可以子类的构造函数第一行手动的定义super（参数）；访问父类构造函数的方式。
子类的实例化过程：
结论：
子类中所有的构造函数默认都会访问父类中空参数的构造函数，因为子类每一个构造函数的第一行都有一句隐式的super();
当父类中没有参数的构造函数，子类必须手动的通过super语句形式来指定要访问的父类中的构造函数。
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少有一个构造函数会访问父类中的构造函数。
07.面向对象（final）
final关键字：
（1）作为一个修饰符，可以修饰类，变量，函数。
（2）被final修饰的类不可以被继承，为了避免被继承，屏蔽子类复写功能。
继承对封装是一个挑战。
（3）被final修饰的方法不可以被重写。
（4）被final修饰的变量是一个常量只能赋值一次，即可以修饰成员变量，也可以修饰局部变量。当在描述事物时，一些数据的出现的值是固定的，这时为了增强阅读性，都给这些值起个名字方便阅读，而这个值不需要改变，所以加final修饰，作为常量，常量的书写规范所有字母都大写，如果有多个单词组成，单词间通过下划线连接。
（5）内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
08.面向对象（抽象类）
当多个类中出现了相同功能，但是功能主体不同，这时可以进行向上抽取，这时只抽取功能定义，而不抽取功能主题。
抽象：就是所谓的看不懂。
特点：
（1）抽象方法一定定义在抽象类中。
（2）抽象方法和抽象类都必须被abstract关键字修饰。
（3）抽象类不可以被new关键字创建对象，因为调用抽象方法没有意义。
（4）抽象类的抽象方法要被使用，必须由子类复写出所有的抽象方法后，建立子类对象调用。
如果子类覆盖了部分抽象方法，那么该子类还是一个抽象类。
09.面向对象（抽象类2）
抽象类和一般类没有太大的不同，该如何描述事物就如何描述事物，只不过该事务中出现了一些看不懂的东西，这些不确定的部分也是该事务的功能，需要明确出现，但是无法定义主体。通过抽象方法来表示。
抽象类比一般类多了抽象方法（函数）。
抽象类不可以被实例化。
作用就是不让该类建立对象。
抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
10.面向对象（抽象类练习）
11.面向对象（模板方法模式）
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减。
方法：使用System类的currentTimeMillis();
当代码完成优化后，就可以解决这类问题。
这种方式就是模板方法设计模式。
什么是模板方法呢？
在定义功能是，功能的一部分是确定的，但有一部分是不确定的，确定的部分再使用不确定的部分，那么这时候将不确定的部分暴漏出去，又该类的子类去完成。
12.面向对象（接口）
接口：初期理解可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的方式来表示。interface用来定义接口。
接口定义时的特点：
（1）接口中常见定义：变量，抽象方法。
（2）接口中成员都有固定修饰符，
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以被实例化，否则子类是一个抽象类。
interface编译后也是一个class文件。
13.面向对象（接口2）
接口可以被类多实现。也是对多继承不支持，对接口可以进行多实现。
实现接口：implements
一个类在继承一个类的同时，可以实现多接口。
类与类之间是继承关系，类与接口之间是实现关系，接口与接口之间是继承关系。
java只有在接口和接口之间可以实现多继承。
14.面向对象（接口的特点）
接口的特点：
接口是对外暴漏的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是多实现关系，而且类可以在继承一个类的同时实现多接口
接口与接口之间可以有多继承
15.面向对象（接口举例体现）
基本功能定义在类中，扩展功能定义在接口中。