基础加强____【Java基础常见问题及难点梳理】

一些基础知识的总结，都是干货

在编辑器中编写的，为保持原有格式就插入到代码

基础知识：
1，配置path和clsspath
	配置path是为了告诉系统程序运行环境所在的位置（命令行查找文件顺序：先当前，后path）
	配置classpath是为了告诉系统要执行的class字节码文件所在的位置(命令行查找文件顺序：先classpath，后当前)
	//也可以不配置classpath,但是要在该文件所在的目录下执行，否则会抛出异常，也可在命令行配置临时的classpath

2, break&continue&return 的区别
		都会结束本次操作
		都只能放在末尾，后面不能跟其它语句，因为执行不到
	break:跳出当前循环
		只能用于循环或者 switch 语句，否则编译报错
	continue:结束本次循环继续下次循环
		只能用于循环结构
		循环嵌套时，可以通过"标号"来 break|continue 指定的(外)循环
	return: 用于方法末尾，函数声明有具体返回值就一定有return

	方法签名：方法名和方法的参数列表
3，内存结构：寄存器、本地方法区、方法区、栈内存、堆内存
	栈：生命周期短，更新速度快
	堆：数组和对象（数组就是对象） new 初始化 垃圾回收机制

排序算法
二维数组（略）

//------------------------------------------
'面向对象的理解：
	面向对象是相对于面向过程而言的，使复杂的问题简单化
	让程序员从程序的执行着变成了程序的指挥者，指挥对象去完成一个个操作
	举例：猫吃鱼，狗吃肉，如果是面向过程，程序员就需要扮演成"猫"和"狗"去完成吃鱼和吃肉的动作
		面向对象的思想是将"猫"和"狗"封装成对象，使其具备"吃"的能力，由调用者指挥对象完成"吃鱼"或"吃肉"的动作

'封装
	1.把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类)；
	2."信息隐藏", 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;
	封装机制在程序中的体现是：把描述对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中，
	并保证外界不能任意更改其内部的字段值，也不允许任意调动其内部的功能方法。

'继承
	继承是从共性到特殊的关系，子类是父类的拓展，为多态提供了前提
	Java仅支持单继承，（相对于C++避免了调用方法的不确定性）不支持多继承，但是支持多重继承，多重继承形成了java的继承体系
	如果单继承不能满足需求，可以实现接口以提供额外的功能
	注：继承会打破封装性
		如
'多态
	多态首先要有继承关系，多态能够通过覆盖访问子类中子父类公有方法，不能访问子类中的特有方法
	如果要访问子类特有方法需要将该对象向下转型
	编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。
	如果编译时类型和运行时类型不同，就出现多态。
	如：Person p = new Student();
	区别:
	多态编译时：方法重载
	多态运行时：方法覆盖

'局部变量和成员变量的区别
	1,作用范围不同：局部变量只能在方法体中访问，位于栈内存；成员变量在类体中都能访问，位于堆内存
	2,生命周期不同：局部变量方法体执行一结束就消失了，成员变量随对象而消失
	3,成员变量会默认初始化，局部变量需要手动初始化

基本数据类型和引用数据类型的区别：前者是赋"值"，后者是赋"址"

'OverRide与OverLoad的区别：覆盖与重载

	覆盖是子父类中，子类中方法要和父类中方法标识完全匹配（返回值、方法名、参数），
	子父类方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
	//（即父类类型的子类对象调用该方法时调用的依然是父类方法）
	//如单例设计模式就是私有化其构造函数导致不能被覆盖，从而保证对象的唯一性

	重载存在于在同一个类中，方法名称相同，参数列表不同(个数或类型)，与返回值无关。
	调用时根据参数列表来区分调用哪一个方法；如果仅仅是返回值不同，函数名和参数列表都相同，编译会报错，
	因为调用的不确定性;		一个类的多个构造方法是以重载的形式存在的


关键字: this&super 本类对象的引用&父类对象引用

static 静态 随着类的加载而加载，只加载一次，优先于对象存在；
	执行顺序：静态代码块-->构造代码块-->构造方法
	被 static 修饰的成员变量表示在该类中共享的数据，被多个实例对象操作时不会被初始化
	

区分: final finally finalize
　	final 可以修饰类,方法,变量。表示不可以被更改
		被修饰的类不能做为父类被继承，但是可以作为子类
		被修饰的方法只能使用，不能被覆盖，如果父类方法不想被子类覆盖，就可以加上final
		被修饰的变量在声明时必须有值，作为常量来使用
	finally 在 try catch 时用于修饰局部代码块，表示一定会执行，(无视 break&return)除非直接退出虚拟机(System.exit)
		通常用于关闭资源
	finalize Object 中的方法，用于垃圾回收

Object 方法： equals hashCode getClass toString
		getClass方法获取该类的运行时类（字节码文件），在反射中会用到
		一个类的两个对象获取的运行时类是同一个
//-----------------------------------------------------------

'内部类（重点&难点）
	概念：一个类定义在另一个类里面,编译后会产生一个Outer$Inner.class文件
	访问特点：内部类可以直接访问外部类中的成员。外部类要访问内部类，必须建立内部类的对象。
	使用：比较常用的是匿名内部类；匿名内部类必须继承或者实现一个外部类或者接口。
	"匿名内部类"：其实就是一个匿名子类对象。该对象编写时体积比较庞大（包含方法体）
	难点：颠覆了传统认知的类格式，阅读性比较差，难以理解，这也是内部类的难点所在
	格式： new 父类or接口(){子类内容}	//要注意多态
示例：
	abstract class father{
		abstract show();
	}
	class Outer{
		method(){//匿名内部类实现show方法，调用show方法
			new father(){ show(){} }.show();//简写
		}
	}

　　内部类在局部时，只可以访问被final修饰的局部变量。 

	内部类在java源码中的体现： 集合框架中的迭代器 Iterator ListIterator 就是在集合类中以内部类的形式存在的
		private class...  通过对外提供的方法 iterator() 获取集合对象


//-----------------------------------------------------------

'单例设计模式：饿汉式&懒汉式
	保证对象的唯一性
	①私有化静态方法，②将对象引用声明为静态，③对外提供一个公有方法去访问
class SingleDemo{
	private static SingleDemo s1 = new SingleDemo();
	private SingleDemo(){}
	public static SingleDemo getS1() {
		return s1;
	}
}

枚举单例
	enum Sig{
		signal;
		private Sig(){}	//私有化构造方法，即使反射也不能创建对象，安全性
	}

//-----------------------------------------------------------
'抽象类&接口
	都是不断向上抽取而来的
	抽象类是从多个类中抽取出来的模板，抽象类一定是父类，有构造方法，但是不能实例化
		有抽象方法的类一定是抽象类；而抽象类中可以不定义抽象方法，如适配器
	abstract 不能和 private&final&static 关键字共存
	interface 接口（无构造方法） 是更彻底的抽取，所有方法都是抽象的；
	当然，也有没有方法的接口，被称为"标记接口"；例如IO流中的序列流 Serializable 接口

	接口是用来制定规则，也可以理解为一种声明，告诉调用者该类具有该接口中定义的功能。
		如果一个类实现了一个接口，那么这个类必须实现该接口中的抽象方法；
	通常，抽象类用于完成继承体系，接口用于实现功能扩展
		在java中的体现:	抽象类:Reader&Writer  InputStream&OutputStream IO流的基类
						接口： Collection -->List&Set||Map 集合体系
					
	Java中多继承之所以不被支持，是因为如果两个父类的方法有方法体，会导致调用的不确定性
	而接口的方法没有方法体,方法体由子类复写；所以支持多实现,且接口与接口之间可以多继承
		

设计模式之"适配器模式"
	如果一个接口中有多个方法，而每次只用到其中一个功能，每次都把接口中的功能实现显然是很浪费的，
	可以先定义一个抽象类实现该接口，然后用到该功能时继承该类即可；这样只需覆盖要用到的方法。
	如GUI编程中的AWT适配器，继承了接口，该适配器是一个没有抽象方法的抽象类
	定义抽象目的就是不让该类创建对象，必须被继承才能创建。通常这种抽象类中的方法有方法体，但是却没有内容。

设计模式之"模板模式" 
	在定义功能时，功能的一部分是确定的，但有一部分是不确定的（抽象）
	确定的部分在使用不确定的部分，将不确定的部分暴露出去，由该类的子类去完成
	如：获取一段代码的运行时间，getTime方法确定，runCode不确定


//-----------------------------------------------------------
异常关键字
throw&throws||try&catch	//通常配合使用
	throws	用于方法体，表示异常声明	//throws通常为解决不了的异常
	throw	抛出异常对象, throws&throw 都可以各自单独使用; try catch 必须一起使用
	try		代码块中装载可能会有异常的代码块	//catch 可以解决的异常
	catch	对 try 代码块产生的异常进行捕捉，可以进行处理，也可以抛出去由调用者处理

	Throwable 类是 Java 语言中所有错误或异常的超类。
		只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。
		类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

	一般来说，一个异常在方法体上声明出来就不需要再 try catch 了，但是不建议这么做,throws 用于声明在本字段无法处理的异常
	开发中通常要对可能出现的异常进行处理，处理异常在 catch 时进行

	继承中的异常：子类只能抛出父类异常或父类异常的子类	
		如果父类方法没有抛出异常，子类覆盖该方法时不能抛异常，只能try


问题：、如何处理Java中空指针异常 java.lang.NullPointerException 

	使用基本的JAVA数据类型，变量的值要么已经是默认值，如果没有对其正常赋值，程序便不能通过编译，
	因此使用基本的JAVA数据类型(double,float,boolean,char,int,long)一般不会引起空指针异常。
	由此可见，空指针异常主要跟与对象的操作相关

	异常处理方式 1) 检查到异常出现，设置对象值为空字符串或一个默认值；
	异常处理方式 2) 检测到异常出现，根本不执行某操作，直接跳转到其他处理中。
	异常处理方式 3) 检查到异常出现，提示用户操作有错误。

总结：编程时要养成初始化变量的习惯，无论是局部变量还是成员变量

待续。。。