黑马程序员---前序《对部分基础知识的查漏补缺》

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

前序

 

       这段学习的日子过的很充实，在博客的第一篇里面，我想把这几天对基础知识复习时的盲点写一下，以便于更加牢固、深刻的掌握这些知识。同时也给大家做个参考，开始我的博客之旅。我喜欢编程，顺着这条路大家一起奋斗下去吧！、

 

switch语句

       关于switch语句中可以使用的数据类型为：byte,short,int,char,枚举(JDK5以后),String(JDK7以后)

       分析： 关于这个问题，相信大家都不会太在意，所以犯错的几率还是很大的。尤其是没有基础或者是基础不扎实的同学或者自学者。虽然在工作中，很少会在这个方面出现问题，但是最基础的东西大家要记住还是没有坏处的。

 

抽象方法和构造方法

      抽象方法不能有方法体，修饰符为public abstract；构造方法不能有返回值。

 

        构造方法：
              1.当实例化一个类的对象时，JVM会自动调用本类的一个方法：构造方法；
              2.定义类时，可以不定义构造方法，编译器会自动添加一个无参，什么都不做的构造方法；
              3.如果类中定义了构造方法，编译器就不会添加任何构造方法了；
              4.构造方法的格式要求：
                    1).构造方法名必须与类名一致；
                    2).构造方法不能定义“返回值类型”，甚至是void；
                    3).构造方法不能返回一个具体的值，但内部可以使用return;语句；
      注意：
              1).以下代码可以编译通过：
    class Student(){
     public void Student(){  //普通成员方法，不是构造方法；
     }
    }
               2).以下代码不能通过编译：
    class Student(){
     public student(){  //构造方法必须同类名一致，包括大小写；
     }
    }


         一个类中可以定义多个“构造方法”，但每个构造方法的形参列表不能完全相同，叫：构造方法的重载；
         在一个构造方法中可以调用另一个构造方法，使用this关键字；
         构造方法可以调用“成员方法”，但“成员方法”不能调用构造方法；

 

                                                                        接口

       接口内：成员变量全部都是最终变量，不可以被重新赋值，修饰符为public static final;成员方法全部是抽象方法，修饰符为public abstract

     “接口”的特点：
                1).不能被实例化，没有构造方法，只能用于子类“实现”；
                2).可以包含：
                   A.成员变量(常量)：隐式的定义为：public static final。
                   上述三个关键字中任何一个都可以不写，系统会自动添加；
      例如：
      interface IA{
       public int num1 = 10;  //OK
       static final int num2 = 20; //OK
       final int num3 = 30;  //OK
       public final num4 = 40;  //OK
       int num5 = 50;   //OK
      }
                  B.抽象方法：隐式的定义为：public abstract。可以省略，系统会自动添加
      例如：
      interface IA{
       void show1();  //OK
       public void show2(); //OK;
       abstract void show3(); //OK;
      }
            3).接口的功能是：扩展功能；


 
         子类实现接口时，必须重写接口中所有的抽象方法，而且必须是public的--因为接口中抽象方法的定义隐式的是public的。
    例如：
     interface IA{
      void show();
     }
     class B implements IA{
      void show(){  }       //编译错误。父接口的show()隐式的为public的，子类重写时必须是public的；
     }

                   

 

                                                                   匿名对象与几个常用关键字

           匿名对象：
                 1.匿名对象：没有名字的对象：new Student();
                 2.匿名对象的两种使用情况：
                            1).对象调用方法仅仅一次的时候:new Student().show();
                            2).作为实际参数在方法中传递:printStudent(new Student());

         final关键字面试题
                  final修饰局部变量，在方法内部，该变量不可以被改变
                                                在方法声明上：(1)基本类型，是值不能被改变   (2)引用类型，是地址值不能被改变

        final关键字修饰：
                成员变量：表示其变量拥有最终的值，不能被更改，成为"常量"。修饰基本数据类型：表示其值不能被修改。修饰引用数据类型，表示地址不能被修改；
               成员方法：表示最终的方法。不能被重写；
               类：表示最终类。不能被继承；
               局部变量：表示其值不能改变；区分：基本类型和引用类型；
               方法形参：表示其值不能改变；区分：基本类型和引用类型；

 

 

        被static修饰的成员变量和成员方法，可以直接被类名调用；而其他普通成员，则需要创建对象后使用对象调用。


         对于被abstract修饰的抽象方法，子类中必须重写此方法，否则编译错误。

 


                                                               关于单例设计模式--一道经常遇到的面试题

 

        多线程中的单例设计模式：饿汉式、懒汉式面试题
        关于懒汉式的程序考点很多，要背诵，并且要理解。

        

/*
 单例设计：饿汉式、懒汉式
 重点：懒汉式  
 面试题：1.问：懒汉式和饿汉式有什么不同？
        答；懒汉式的特点在于实例的延迟加载。
    2.问：懒汉式的延迟加载有没有问题？
    答：有，如果多线程访问时会出现安全问题。
   3.问：怎么解决？
    答：可以通过加同步来解决。
   4.问：加同步的方式？
    答：用同步代码块可以，但效率有点低；可以用
    双重判断的方式提高效率。
   5.加同步的时候使用的锁是：该类所属的字节码文件
*/


//饿汉式
class Single
{
 private static final Single s = new Single();
 private Single(){
 
 }
 public static Single getInstance(){
  return s;
 }
}


//懒汉式
class Single 
{
 private static Single s =null;
 private Single(){
 
 }
 public static Single getInstance(){
  if (s==null){
   synchronized(Single.class){
    if(s==null)
    s = new Single();
   }
  }
  return s;
 }
}

 

 

 

                                                                      == 与 equals区别

判断运算符：==
    1.如果两边是基本数据类型，比较的值是否相等；
    2.如果两边是"引用数据类型"，比较的是"引用(地址)"是否相等；
equals方法：
    1.只能判断引用数据类型； 
    2.在Object类中定义，任何类都会继承此方法；
    3.在Object类中默认实现：判断两个对象的地址是否相同；
    4.我们一般都会重写此方法，判断对象内部的属性值是否全部完全相同；