Java重点基础巩固

我不是女神ヾ 2022-08-09 14:43 135阅读 0赞

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

1.  **Java 内部类：**  
    看过几篇博客，觉得写得很深很详细，贴出博客地址：：[http://www.cnblogs.com/dolphin0520/p/3811445.html][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_20000769]，[http://blog.csdn.net/zhangjg\_blog/article/details/19996629][http_blog.csdn.net_zhangjg_blog_article_details_19996629]  这几篇要按序阅读哦，再补充两篇：[http://blog.csdn.net/zhaoqianjava/article/details/6849812][http_blog.csdn.net_zhaoqianjava_article_details_6849812]，[http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html][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][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<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();”会比较合适一些  
    
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. **定义一个每行元素个数不同的二维数组：**  
    
    
        <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>
    
      
    
20. **面向对象的程序设计的主要特征：**  
    3个主要特征：  
    ①封装性；  
    ②继承性：是子类共享其父类数据和方法的机制。是面向对象程序设计中软件复用的关键技术，在Java中支持单继承和多层继承（不支持多继承，即一个类只能继承一个类而不能继承多个类）。在继承时子类会将父类的全部成员（数据和方法）继承下来，对于所有的非私有成员属于**显式继承**，对于所有的私有成员采用**隐式继承，子类无法直接操作这些私有属性，必须通过Setter和Getter间接操作。**在构造方法的调用次序上是先调用父类，再调用子类。最后，被final 修饰的类不能再被继承。  
    ③多态性：方法多态性：体现在方法的重载和覆写上。对象多态性：体现在父、子对象的转型上，即子类对象可以视为父类对象。转型包括：A：向上转型就是将子类对象赋值给父类对象，这种方式是安全的。B：向下转型（强转）是将父类对象赋值给子类对象，这种方式是非安全的。
21. **Java 中String、StringBuilder和StringBuffer的区别：**  
    ①这三者都是使用字符数组保存字符串，但String是不可变的，后两者是可变的。  
    ②String中的对象是不可变的，也就可以理解为常量，所以**是线程安全**的。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以也**是线程安全**的。只有StringBuilder **不是**线程安全的。  
    ③从上述两个特点可以看出：在用 String 对字符串用  +  进行频繁连接时，系统会不断地创建对象并复制，会造成性能低下，所以在进行频繁的字符串连接时尽量选择 StringBuilder，要求线程安全时使用StringBuffer。

[http_www.cnblogs.com_dolphin0520_p_3811445.html]: 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/20000769
[http_blog.csdn.net_zhangjg_blog_article_details_19996629]: http://blog.csdn.net/zhangjg_blog/article/details/19996629
[http_blog.csdn.net_zhaoqianjava_article_details_6849812]: http://blog.csdn.net/zhaoqianjava/article/details/6849812
[http_www.cnblogs.com_nerxious_archive_2013_01_24_2875649.html]: http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html
[http_blog.csdn.net_tounaobun_article_details_8491392]: http://blog.csdn.net/tounaobun/article/details/8491392