Java重点基础巩固

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

1. Java 内部类：
   看过几篇博客，觉得写得很深很详细，贴出博客地址：：http://www.cnblogs.com/dolphin0520/p/3811445.html，http://blog.csdn.net/zhangjg_blog/article/details/20000769，http://blog.csdn.net/zhangjg_blog/article/details/19996629  这几篇要按序阅读哦，再补充两篇：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();
   	}
   }

   
   
   
2. Java中的深拷贝和浅拷贝
   http://blog.csdn.net/tounaobun/article/details/8491392，
   
   
3. 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的作用是用来保证变量不可变。
4. Java中的synchronized ：
   
   1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
   　　例如:
   public  synchronized  void synMethod(){
   　　//方法体
   　　}
   2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.此时,线程获得的是成员锁.例如:
   public Object synMethod(Object a1){
   　　synchronized(a1){
   　　//一次只能有一个线程进入
   　　}
   　　}
   3.synchronized后面括号里是一对象,此时,线程获得的是对象锁.
   4.synchronized后面括号里是类,此时,线程获得的是对象锁.
   
5. Java访问权限（public private protected 默认）
   ①public ：如果将一个类声明成 public ，那么需要保证文件名称和这个类名称相同，也就是说，在一个 Java 文件里，最多只能有一个 public 类，否则 .java 的文件便无法命名。
   ②默认（default）：不需要为某个类、方法加任何访问修饰符，在这种方式下声明的类和方法，只允许在同一个包内访问。
   ③private：类和接口的访问方式是不能被声明为私有的，只有内部类允许私有。
   ④protected：如果一个变量、方法和构造函数在父类中被声明为“保护”访问类型，只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。类和接口的访问方式是不能声明为保护类型的，只有内部类可以设为保护权限。
   除了上述的四个访问控制符，还可以是 final 。一个类一旦被声明为 final ，那这个类不能被继承，final 类的成员方法没有机会被覆盖。
6. static：
   ①static 修饰的成员不能访问没有static 修饰的成员。
   ②static 语句块用于初始化static 成员变量，是最先运行的语句块。
7. 匿名对象：
   ①匿名对象没有被其他对象所引用，即只有分配堆内存而没有栈内存指向。
   ②由于匿名对象没有栈内存指向，所以只能使用一次，之后就变成无法找寻的垃圾对象，故会被垃圾回收器收回。
8. 构造方法：
   ①构造方法的名称和其所属的类名必须保持一致。
   ②构造方法没有返回值，也不可以使用void 。
   ③构造方法也可以重载。
   ④构造方法不能被static 和 final 修饰。
   ⑤构造方法不能被继承，子类使用父类的构造方法需要使用 super 关键字。
9. 构造代码块：
   构造代码块是在类中直接定义的，构造代码块和构造方法一样是在对象生成时被调用的，但是它的调用时机比构造方法还要早。构造代码块可用来初始化成员变量。比如一个类中有多个构造方法并且都需要初始化成员变量，这时可以利用构造代码块来完成，提高代码的复用性。
   

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

10. 静态代码块
    使用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("构造方法执行");
    	}
    }

11. 枚举类型：
    ①枚举类型不能用public 和 protected 修饰符修饰构造方法，构造方法的权限只能是 private 或者默认权限。所以枚举对象无法在程序中通过直接调用其构造方法来初始化。
    ②枚举类不可以被继承，在枚举类内部可以定义一个或多个抽象方法，但是要为枚举中的每个对象单独实现此抽象方法。枚举不能用  abstract 修饰。
12. HashMap、ArrayList、StringBuilder 和 Hashtable、Vector、StringBuffer①后面的三个是线程安全的，但是由于使用了同步机制导致了性能的开销。
13. 使用最有效率的方式去遍历Map
    

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

    如果你只是想遍历一下这个Map的key值，那用”Set keySet = hm.keySet();”会比较合适一些
    
14. 把一个基本数据类型转为字符串基本数据类型.toString()是最快的方式、String.valueOf(数据)次之、数据+”"最慢。
15. 从键盘读入数据：

    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();
    	}
    }

16. Java中变量的作用范围（按作用范围划分：分为 成员变量 和 局部变量）
    ①成员变量：在类体中定义的变量称为成员变量，它的作用范围为整个类。
    ②局部变量：在一个方法或方法内代码块 中定义的变量称为局部变量。局部变量在方法或代码块被执行时创建，在方法或代码块结束时被销毁。注意：局部变量在进行取值操作前必须被初始化或赋值操作。
17. 类型转换
    ①在Java 中boolean 类型不可能与其他任何数据类型进行转换。整数与浮点数可以相互转换。
18. &和&&、|和|| 的关系怎样：
    ①对于“与操作”：有一个条件不满足，结果就是 false。普通与（&）：所有的判断条件都要执行；短路与（&&）：如果前面有条件已经返回了 false，不在向后判断，最终结果也是false。
    ②对于“或操作”：有一个条件满足，结果就是true。对于普通或（|）：所有的判断条件都要执行；短路或（||）：如果前面有条件返回了true，就不在向后判断，那么最终结果就是true 。
19. 定义一个每行元素个数不同的二维数组：
    

    int[][] num = null;
    num = new int[3][];
    num[0] = new int[4];
    num[1] = new int[3];
    num[2] = new int[6];
    

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

    num.length        //数组num 的行数
    num[0].length   //第一行元素的个数为 4
    num[3].length   //第三行元素的 个数为 6

    
    
20. 面向对象的程序设计的主要特征：
    3个主要特征：
    ①封装性；
    ②继承性：是子类共享其父类数据和方法的机制。是面向对象程序设计中软件复用的关键技术，在Java中支持单继承和多层继承（不支持多继承，即一个类只能继承一个类而不能继承多个类）。在继承时子类会将父类的全部成员（数据和方法）继承下来，对于所有的非私有成员属于显式继承，对于所有的私有成员采用隐式继承，子类无法直接操作这些私有属性，必须通过Setter和Getter间接操作。在构造方法的调用次序上是先调用父类，再调用子类。最后，被final 修饰的类不能再被继承。
    ③多态性：方法多态性：体现在方法的重载和覆写上。对象多态性：体现在父、子对象的转型上，即子类对象可以视为父类对象。转型包括：A：向上转型就是将子类对象赋值给父类对象，这种方式是安全的。B：向下转型（强转）是将父类对象赋值给子类对象，这种方式是非安全的。
21. Java 中String、StringBuilder和StringBuffer的区别：
    ①这三者都是使用字符数组保存字符串，但String是不可变的，后两者是可变的。
    ②String中的对象是不可变的，也就可以理解为常量，所以是线程安全的。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以也是线程安全的。只有StringBuilder 不是线程安全的。
    ③从上述两个特点可以看出：在用 String 对字符串用  +  进行频繁连接时，系统会不断地创建对象并复制，会造成性能低下，所以在进行频繁的字符串连接时尽量选择 StringBuilder，要求线程安全时使用StringBuffer。