Java编程思想--学习笔记

对象导论

1.类的被隐藏。Java用3个关键字在类的内部设定边界：public、private、protected。Public 表示后面的元素对任何人都是可用的，private表示除类型创建者和类型的内部方法之外的任何人都不能访问，protected基本和private相同，只不过继承的类可以访问protected成员，而不能访问private成员。
2.复用性。一个类被创建并测试完成，就是一个有用的代码单元，最简单的复用某个类的方法就是直接使用该类的一个对象。
3.继承（可扩展性）。当一个需要创建的类和原有的类具有相似的概念时，可以以原有类为基础，然后通过添加或修改这个副本来创建新类。如果父类发生改变，子类也会反应这些变动。子类复制了父类的接口，子类和父类具有相同的类型，即：通过继承而产生的类型等价性。如果子类单纯继承父类而不做其他任何事，那么父类接口中的方法将直接继承到子类中。子类与父类产生差异方法有：1.直接在子类中添加新方法。2.覆盖父类中的方法。
4.Java中动态绑定是默认行为。不需要添加额外的关键字来实现多态。
5.向上转型。将子类看做父类的过程叫做向上转型。
6.单根继承结构。所有类最终都继承自单一的父类（基类），即Object。
7.容器。为了避免创建一种对象类型来满足解决特定问题，Java类库中有满足各种不同需求的容器，如list、map、set……
8.泛型。使用尖括号，中间包含类型信息，例如：ArrayList<Shape[Shape表示一个类，本例是图形，下含start、squce等具体子类。]> shape = new ArrayList(); 表示定制一个只接收和取出Shape对象的容器。
9.垃圾回收。Java提供“垃圾回收器”，自动销毁不用的对象，释放内存。

一切都是对象

1.用引用操纵对象。如

String s;//创建对象的引用，并不是对象 
String s = "abdc";//初始化对象的引用
{
String s = new String("abc");
//对象的应用建立与对象的关系，值得注意的是， s 这个引用在作用域终点"}"处就消失了，但是 s 指向的string对象却依然存在。
}

2.存储。寄存器（CPU内部）、 堆栈（存放Java对象的引用） 、 堆（通用内存池，存放所有Java对象）、常量存储（通常写在Java代码内部）、非RAM存储（持久化对象）。
3.基本类型。基本类型存在是因为new的对象存放于堆中，效率远没有堆栈中效率快，所以创建小的、简单的变量并不是很有效。所以创建一个并非是引用的“自动”变量，变量直接存储“值”，置于堆栈中，更加高效。 所有数值类型都有正负号。基本类型：boolean、char、byte、shot、int、long、float、double、void。
4.数组。创建一个数组对象时，实际上就是创建了一个引用数组，且每个引用都会自动初始化为一个特定值：null。Null表示这个引用还没有指向某个对象。
5.对象的作用域。例如：{String s = new String(“test s”);}，引用 s 在作用域终点 “}”处就消失了，然而s 指向的String对象仍然继续占据内存空间。Java提供“垃圾回收器”，自动销毁不用的对象。
6.创建新的数据类型：类。字段和方法是两种类型的元素。
7.Static关键字。Static重要的一个用法就是不需要创建对象就可以调用。

操作符

1.关系操作符（<、>、 >=、<=、==），赋值运算符“=”。
2.逻辑操作符（&&、||、！）。
短路:

test(1) && test(2) && test(3); 
//如果test(1)为true，那么继续test(2)，如果test(2)为false，则整个表达式为false，test(3)不做判断
//这种情况叫做短路

3.指数计数：1.3e-19f 等价 1.3*10^-19。
4.底层操作符。按位操作符、移位操作符。
5.类型转换操作符。Long test = （long） intValue[Int类型];
6.表达式中最大的数据类型决定表达式最终结果的数据类型。

控制执行流程

1.Java中控制流程关键字：if-else、while、do-while、for、return、break和switch.
2.If – else if – else。else if 并不是关键字，只是else后紧跟了另一个if语句。
3.迭代。For ,while, do-while用来控制循环，也归类为迭代语句。
Foreach(高级for循环):

//普通for 遍历数组 array[int]
for(int i = 0; i < array.length; i++){
	logger.debug(array[i]);
}
//高级for 遍历数组
for(int x : array){
	logger.debug(x);//定义一个int 类型 x ，继而把每一个array元素赋值给 x
}

4.Return 。主要两个用途，一个是指定非void方法返回什么值，一个是导致方法退出，并返回那个值。
5.Break。强制退出循环，不执行余下代码行。退出最内层循环。
6.Continue。停止执行当前迭代，返回循环起始处，开始新的迭代。退出最内层循环。带有标签的退出到标签。

Out:
For(int i=0;i<100;i++){
	Logger.debug(i);
	Continue out;//终止当前循环，并跳出到out:标签处
	Break out;//中断当前循环，并跳出标签所指的循环。
}

7.无限循环。While（true）或 for( ; ; );

初始化与清理

1.构造器确保初始化。构造器名与类名相同。
2.方法重载。通过不同参数区分重载方法。
3.默认构造器。New student() 创建一个新对象，即使代码没有定义，编译器自动创建一个无参构造器。如果已经创建一个构造器，那么编译器不会创建一个默认构造器。
4.This关键字。只能在方法内部使用。通常表示当前对象或这个对象，本身表示对当前对象的引用。
5.Static关键字。Static（静态）方法就是没有this的方法。在没有创建任何对象的前提下，仅仅通过类本身就可用调用static方法。
6.清理。1.对象可能不被垃圾回收，2.垃圾回收不等于折构，3.垃圾回收只与内存有关。
7.数组初始化。下标从0开始，到length-1结束。
8.静态初始化方法只执行一次。

访问控制权限

1.访问控制权限从大权限到小权限依次是：public、protected、包访问权限（没有关键字）、private。
2.包。包内含有一组类，它们各自拥有唯一名字被组织在一起。
3.一个后缀为.java的文件（编译单元）只能含有一个public类，否则编译器不会接受。如果编译单元还有其他类，那么包外面是看不见这些类的。
4.Package语句。如果使用package语句，必须放在文件中除注释外的第一行。
5.Java解释器运行过程：首先，找出环境变量CLASSPATH，CLASSPATH包含一个或多个目录，用做查找.class文件的根目录。从更目录开始，解释器获取包的名称并将每个句点换成反斜杠，以此从根目录中产生一个路径名称。得到的路径会与CLASSPATH中的各个不同相相连接，解释器在这些目录中查找所创建类名称相同的.class文件。
6.访问权限修饰词。如果不提供诸如public、protected、private的修饰词，就意味着是包访问权限。包访问权限是指包内其他类可以访问这个成员，但成员对包外是private。
7.Protected。继承访问权限，同时提供包访问权限（相同包内的其他类可以访问protected元素）。
8.Void不返回任何东西，但是可以返回对象的引用。
9.类既不可以是private的也不可以是protected的，就是说类只能是public和包访问权限，如果要控制类的访问权限，可以通过指定构造器的访问权限实现。

复用类

1.继承。每创建一个类时候，总会发生继承，没有明确定义继承类，默认继承Java标准根类object。

pubilc class Child extends Father{//Child 类 继承 Father类的所有域和方法
	...
}

2.为了继承，一般将所有数据成员指定为private，所有的方法指定为public。
3.继承视为对类的复用。当创建一个子类的对象时，该对象包含一个父类的子对象（与父类直接创建的对象相同）。
4.确保父类被初始化–继承后的子类在构造器中默认调用父类构造器。
5.final关键字。数据：一个永不改变的编译时常量，在运行时被初始化的值，并不希望改变，以关键字final表示。一个既是static又是final的域占据一块不能改变的存储空间。
用final关键字定义对象引用而不是基本类型时候，意味着引用无法再次指向另一个对象引用，但对象自身是可以修改的。
名称屏蔽：如果父类中拥有某个已被多次重载的方法名称，那么子类中重新定义该方法名称并不会屏蔽父类中的任何版本。
向上转型：新类是现有类的一种类型。即，子类是父类的一种类型。
6.类中所有private方法都隐式地指定为final。Private方法不能被覆盖，继承时并不是可继承接口。
7.final类。不能继承。同时，内部所有方法全部隐式指定为final。

final class testClass(){...}

final方法：防止继承后子类修改方法定义–确保方法行为不变且不会被覆盖。
8.初始化及类的加载。每个类的编译代码存在于自己的独立文件中，该文件只在初次使用时才被加载–通常指创建类的第一个对象时候。访问static域或static方法时也会加载（本质上构造器也是static方法，只是没有显示static而已，更准确的讲：类是在其任何static成员被访问时加载）。
继承与初始化：访问子类的构造器，编译器发现有父类，继续加载基类，如果基类还有基类，则继续向上加载。接下来，根基类的static初始化会被执行，接下来是下一个子类，以此类推。

多态

1.面向对象基本特征（前三）：数据抽象、继承、多态。
向上转型：对象既可以作为他自己本身的类型使用，也可以作为他父类型使用。
如果一个父类被多个子类继承。方法传入参数如果特定为某个子类类型是完全可行的，只不过重复编码太多，可以把参数定义为这些子类共同继承的父类类型来解决这个问题。
绑定：将一个方法调用和方法主体关联起来称作绑定。在程序执行前绑定叫前期绑定。在运行时根据对象的类型进行绑定叫做后期绑定（动态绑定、运行时绑定）。
2.Java所有方法都通过动态绑定实现多态（除static方法和final方法，private方法属于final方法）。
3.缺陷：覆盖私有方法。只有非private方法才能被覆盖。
4.缺陷：域与静态方法。只有普通方法是多态的。如果要访问某个域，这个访问将在编译期进行解析。如果方法是静态的，它就不具有多态性。
5.构造器和多态。构造器是隐式的static方法。构造器的调用顺序：父类的构造器总是在子类的构造过程中被调用，按照继承层次逐渐向上连接，确保每个父类的构造器都被调用。
继承和清理。如果需要执行清理，那么清理的顺序是和初始化顺序相反，先清理子类，然后逐层向上清理。
6.子类可以访问父类的所有public和protected方法和域。

接口

1.抽象类和抽象方法。抽象类是含有抽象方法的类，抽象方法是仅声明没有方法体的方法。使用关键字abstract声明。
2.如果继承抽象类，就要对其中所有抽象方法重新定义，否则子类也是抽象类。
3.接口。Interface关键字，创建一个或多个只定义方法名，返回参数类型而没有方法体的方法。
4.若要实现接口，那么这个接口必须被定义为public（如果不添加public，则只具有包访问权限）。
5.完全解耦。只要一个方法操作的是类而非接口，那么就只能操作这个类及其子类。将接口从具体实现中解耦使得接口可以应用到多种不同的实现，因此代码也就更具有复用性。
6.接口没有具体实现，也就是说没有任何与接口相关的储存。一个类可以继承多个接口，如果继承类，那么只能继承一个类（可继续继承一个或多个接口）。
接口：为了能够向上转型为多个基类型。

class hero extends ActionCharacter implements CanFight, CanSwim, CanFlay{...}

继承接口：可以在新接口中添加新的方法声明。

interface Empir extends County{...} //County 为一个接口

7.接口中的域。由于接口中的任何域都是自动的static和final，所以接口成为一个很便捷的常量创建工具。接口中的域不能是“空final”,这些域不是接口的一部分，它们的值被存储在该接口的静态存储区域内。
8.接口可以嵌套在任何类和接口中。Private接口实现：强制该接口中的方法定义不要添加任何类型信息（不允许向上转型），不能在定义它的类之外被实现。

内部类

1.可以将一个类的定义放在另一个类的定义内部，这就是内部类。
2.最初，内部类是一种隐藏机制。
3.内部类可以访问其外围对象的所有成员，而不需要特殊条件，内部类拥有其外围类所有元素的访问权[当某个外围类创建一个内部类对象时，内部类对象必定捕获一个指向外围类对象的引用。]。
4.创建内部类的对象引用，必须使用外部类的对象来创建该内部对象。

Teacher t = new Teacher();//外部类对象引用
Teacher.Student s = new t.new Student();//内部对象的引用

5.在拥有外部类对象引用之前，不可能创建内部类的引用，除非创建的是嵌套类（静态内部类）。
6.在方法创建的内部类–局部内部类。
7.匿名类。匿名类中不可能存在有名构造器（匿名类没有名字）。通过实例初始化达到为匿名内部类创建一个构造器的效果。实例初始化的效果就是构造器，但是不能重载实例初始化方法，所以仅有一个这样的构造器。
8.嵌套类。如果不需要内部类对象与其外围类对象之间有联系，那么可以将内部类声明为static，这通常称作嵌套类。
9.嵌套类意味着（1）创建嵌套类的对象不需要其外围类的对象。（2）不能从嵌套类的对象中访问非静态类的外围类对象。
10.嵌套类和普通类还有一个区别：普通类不能含有static数据和static字段，也不能包含嵌套类。而嵌套类都可以包含这些。
11.多层嵌套类。一个内部类被嵌套多少层并不重要–它能够透明的访问所有它所嵌套的外围类成员。
12.为什么使用内部类。每个内部类都能独立地集成自一个（接口）的实现，无论外围类是否已经继承某个接口的实现。内部类解决了“多重继承”问题，也就是说内部类可以继承多个非接口类型（类或抽象类）。
13.内部类特性：解决“多重继承”问题；内部类可以有多个实例，并且与外围类对象的信息相互独立；在单个外围类中，多个内部类可以以不同方式实现同一个接口；创建内部类对象的时刻并不依赖外围类对象的创建；内部类是一个独立的实体。
14.闭包与回调。闭包：闭包是一个可调用对象，它记录一些信息，这些信息来源创建它的作用域。通过定义可以看出，内部类是外围类的闭包。回调：通过回调，对象能够携带一些信息，这些信息运行它在稍后的某个时刻调用初始的对象。
通过内部类提供的闭包功能实现回调。（模糊）
15.内部类的继承。如果要单纯的继承内部类而不是其外围类，而问题在于内部类指向外围类对象的引用必须被初始化。可以通过特殊语法解决。

class WithInner{
	class Inner{...}
}
public class TestInner extends WithInner.Inner{
	TestInner(WithInner wi){//有参构造器
		wi.super();
	}
	//TestInner(){}  不能实现
}

16.局部内部类。局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量以及此外围类的所有成员。
17.内部类标识符。每个类都会产生一个.class文件，内部类也生成一个.class文件，命名规则有严格规则：外围类的名字 + “$” +内部类的名字。

持有对象

1.泛型和类型安全的容器。
2.基本概念：Java容器类库用途是保存对象，划分为两个不同的概念：
Collention和Map:collention包括：List–以特定顺序保存一组元素；Set–元素不能重复；Queue–值允许在容器一端插入对象。Map对于每一个键，Map只接受一次。理解参考：https://www.cnblogs.com/taiwan/p/6954135.html
3.List
Array List：长于随机访问元素，但是在List的中间插入和移除元素时较慢。
LinkedList：在随机访问方面较慢，但在List中间插入和移除较快。特性集较Array List大。
4.迭代器：迭代器是一个对象，工作是遍历并选择序列中的对象。轻量级对象（创建代价小）。