Java重点基础巩固

虽然在大学学过Java，但是只是入门，甚至连入门都不算，觉得自己对Java基础知识方面还有算欠缺，所以最近抽时间巩固了一下Java的基础知识，在此将笔记记下来希望能帮助大家：

Java 内部类：

看过几篇博客，觉得写得很深很详细，贴出博客地址：：http://www.cnblogs.com/dolphin0520/p/3811445.html，/article/1381873.html，/article/1381874.html
这几篇要按序阅读哦，再补充两篇：http://blog.csdn.net/zhaoqianjava/article/details/6849812，http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html 。

一个朋友给我说的一道关于内部类的题目，大家可以看一下这道题输出是什么（输出会超乎你的意料，快自己运行试试吧），源码如下：

public class Base {
	private String baseName="base";

	public Base(){
		callName();
	}

	public void callName() {
		System.out.println(baseName);
	}

	static class Sub extends Base {
		private String baseName="sub";

		public void callName() {
			System.out.println(baseName);
		}
	}

	public static void main(String[] args) {
		Base base = new Base.Sub();
	}
}

Java中的深拷贝和浅拷贝

/article/2316802.html，

Java中 final 关键字用法

final 是用来定义常量的，定义常量时注意：①必须要在常量声明时对其进行初始化，而且一旦初始化之后，就无法再次对这个常量进行赋值操作了。②不仅可以修饰基本数据类型，还可以修饰对象引用 或者方法。

在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。

(1) 修饰类

当用final修饰一个类时，表明这个类不能被继承。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。Java编译器会寻找机会内联所有的final方法，内联对于提升Java运行效率作用重大。

(2)修饰方法

下面这段话摘自《Java编程思想》：“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。注：类的private方法会隐式地被指定为final方法。

(3)修饰变量

首先了解一下final变量的基本语法：对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。那问题来了，被final修饰的引用变量指向的对象内容可变吗？答案是：它指向的对象的内容是可变的。

final 和 static 比较：static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。
Java中的synchronized ：

1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.

　　例如:

public synchronized void synMethod(){

　　//方法体

　　}

2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.此时,线程获得的是成员锁.例如:

public Object synMethod(Object a1){

　　synchronized(a1){

　　//一次只能有一个线程进入

　　}

　　}
3.synchronized后面括号里是一对象,此时,线程获得的是对象锁.

4.synchronized后面括号里是类,此时,线程获得的是对象锁.

Java访问权限（public private protected 默认）

①public ：如果将一个类声明成 public ，那么需要保证文件名称和这个类名称相同，也就是说，在一个 Java 文件里，最多只能有一个 public 类，否则 .java 的文件便无法命名。

②默认（default）：不需要为某个类、方法加任何访问修饰符，在这种方式下声明的类和方法，只允许在同一个包内访问。

③private：类和接口的访问方式是不能被声明为私有的，只有内部类允许私有。

④protected：如果一个变量、方法和构造函数在父类中被声明为“保护”访问类型，只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。类和接口的访问方式是不能声明为保护类型的，只有内部类可以设为保护权限。

除了上述的四个访问控制符，还可以是 final 。一个类一旦被声明为 final ，那这个类不能被继承，final 类的成员方法没有机会被覆盖。
static：

①static 修饰的成员不能访问没有static 修饰的成员。

②static 语句块用于初始化static 成员变量，是最先运行的语句块。
匿名对象：

①匿名对象没有被其他对象所引用，即只有分配堆内存而没有栈内存指向。

②由于匿名对象没有栈内存指向，所以只能使用一次，之后就变成无法找寻的垃圾对象，故会被垃圾回收器收回。
构造方法：

①构造方法的名称和其所属的类名必须保持一致。

②构造方法没有返回值，也不可以使用void 。

③构造方法也可以重载。

④构造方法不能被static 和 final 修饰。

⑤构造方法不能被继承，子类使用父类的构造方法需要使用 super 关键字。
构造代码块：

构造代码块是在类中直接定义的，构造代码块和构造方法一样是在对象生成时被调用的，但是它的调用时机比构造方法还要早。构造代码块可用来初始化成员变量。比如一个类中有多个构造方法并且都需要初始化成员变量，这时可以利用构造代码块来完成，提高代码的复用性。

class Test{
	private int x;
	private String name;
	//构造代码块
	{
		System.out.println("构造代码块执行");
		x = 10;
		name = "xxx";
	}
	
	public Test(){
		System.out.println("构造方法执行");
	}
}

静态代码块

使用static 关键字加以修饰并用大括号括起来的代码块称为静态代码块，主要用来初始化静态成员变量。它是最早执行的代码块。静态代码块的执行时间比主方法main() 方法都要早，静态代码块是在类加载的时候执行的，静态代码块的执行级别是最高的。

class Test{

	public static int x;
	public static String name;
	//静态代码块
	static
	{
		System.out.println("静态代码块执行");
		x = 10;
		name = "xxx";
	}
	
	public Test(){
		System.out.println("构造方法执行");
	}
}

枚举类型：

①枚举类型不能用public 和 protected 修饰符修饰构造方法，构造方法的权限只能是 private 或者默认权限。所以枚举对象无法在程序中通过直接调用其构造方法来初始化。

②枚举类不可以被继承，在枚举类内部可以定义一个或多个抽象方法，但是要为枚举中的每个对象单独实现此抽象方法。枚举不能用 abstract 修饰。
HashMap、ArrayList、StringBuilder
和 Hashtable、Vector、StringBuffer①后面的三个是线程安全的，但是由于使用了同步机制导致了性能的开销。
使用最有效率的方式去遍历Map

public static void main(String[] args)
{
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("111", "222");
Set<Map.Entry<String, String>> entrySet = hm.entrySet();
Iterator<Map.Entry<String, String>> iter = entrySet.iterator(); while (iter.hasNext())
{
Map.Entry<String, String> entry = iter.next();
System.out.println(entry.getKey() + "\t" + entry.getValue());
}
}

如果你只是想遍历一下这个Map的key值，那用”Set<String>
keySet = hm.keySet();”会比较合适一些

把一个基本数据类型转为字符串基本数据类型.toString()是最快的方式、String.valueOf(数据)次之、数据+”"最慢。
从键盘读入数据：

public class Test1 {
	public static void main(String args[]){
		String str;
		//创建标准输入流对象来接受键盘System.in 的输入
		InputStreamReader in = new InputStreamReader(System.in);
		//以缓冲流模式来接收in
		BufferedReader reader = new BufferedReader(in);
		//使用try catch来捕获异常
		try{
			System.out.println("请输入字符串:");
			//用 str 来接收键盘输入的一行数据
			str = reader.readLine();
			System.out.println("你输入的字符串为:"+str);
			reader.close();
			in.close();
		}catch(Exception e){
			System.out.println("发生I/O错误!");
		}
	}
}

public class TestInput {
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		System.out.println(scanner.nextLine());
		scanner.close();
	}
}

Java中变量的作用范围（按作用范围划分：分为 成员变量 和 局部变量）

①成员变量：在类体中定义的变量称为成员变量，它的作用范围为整个类。

②局部变量：在一个方法或方法内代码块 中定义的变量称为局部变量。局部变量在方法或代码块被执行时创建，在方法或代码块结束时被销毁。注意：局部变量在进行取值操作前必须被初始化或赋值操作。
类型转换

①在Java 中boolean 类型不可能与其他任何数据类型进行转换。整数与浮点数可以相互转换。
&和&&、|和|| 的关系怎样：

①对于“与操作”：有一个条件不满足，结果就是 false。普通与（&）：所有的判断条件都要执行；短路与（&&）：如果前面有条件已经返回了 false，不在向后判断，最终结果也是false。

②对于“或操作”：有一个条件满足，结果就是true。对于普通或（|）：所有的判断条件都要执行；短路或（||）：如果前面有条件返回了true，就不在向后判断，那么最终结果就是true 。
定义一个每行元素个数不同的二维数组：

<span style="font-size:14px;">int[][] num = null;
num = new int[3][];
num[0] = new int[4];
num[1] = new int[3];
num[2] = new int[6];
</span>

进一步获取二维数组的行数与特定行的元素的个数：

<span style="font-size:14px;">num.length        //数组num 的行数
num[0].length   //第一行元素的个数为 4
num[3].length   //第三行元素的 个数为 6</span>

面向对象的程序设计的主要特征：

3个主要特征：

①封装性；

②继承性：是子类共享其父类数据和方法的机制。是面向对象程序设计中软件复用的关键技术，在Java中支持单继承和多层继承（不支持多继承，即一个类只能继承一个类而不能继承多个类）。在继承时子类会将父类的全部成员（数据和方法）继承下来，对于所有的非私有成员属于显式继承，对于所有的私有成员采用隐式继承，子类无法直接操作这些私有属性，必须通过Setter和Getter间接操作。在构造方法的调用次序上是先调用父类，再调用子类。最后，被final 修饰的类不能再被继承。

③多态性：方法多态性：体现在方法的重载和覆写上。对象多态性：体现在父、子对象的转型上，即子类对象可以视为父类对象。转型包括：A：向上转型就是将子类对象赋值给父类对象，这种方式是安全的。B：向下转型（强转）是将父类对象赋值给子类对象，这种方式是非安全的。
Java 中String、StringBuilder和StringBuffer的区别：

①这三者都是使用字符数组保存字符串，但String是不可变的，后两者是可变的。

②String中的对象是不可变的，也就可以理解为常量，所以是线程安全的。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以也是线程安全的。只有StringBuilder 不是线程安全的。

③从上述两个特点可以看出：在用 String 对字符串用 + 进行频繁连接时，系统会不断地创建对象并复制，会造成性能低下，所以在进行频繁的字符串连接时尽量选择 StringBuilder，要求线程安全时使用StringBuffer。