Java私塾基础note

大家好，欢迎来到IT知识分享网。

1.boolean 类型不可以用数字表示

2.switch 的表达式expr1只能是整数型的值或者是 enum 枚举类型的常量值，

  包含 byte、short、int 和 char，不能是字符串或对象，也不能是 long 型的值。
 
3.属性：类的属性就是对象所具有的静态属性
  定义规则：访问修饰符  修饰符  类型  属性名称  =  初始值
          public    static String   s   =   “123”；

4.方法就是对象所具有的动态功能
  定义规则：
  访问修饰符  修饰符  返回值类型  方法名称 （参数列表） throws 异常列表 {方法体}
  public    static void      main    (String[] args)          {}
5.new关键字的功能：
 （1）为对象实例分配内存空间
 （2）初始化对象实例

6.this关键字：用来指向当前对象或类实例
  功能：（1）点取成员
        （2）区分同名变量
        （3）作为方法名来初始化对象

7.java类第一步运行：  public static void main（String[] args) {…}

8.初始化一个类必先初始化它的属性

9.局部变量必须在使用之前“手工”初始化

10.凡是用new关键字创造的对象实例都是应用类型
   在java里除去基本数据类型的其他类型都是应用数据类型
   String类型比较特殊殊

11.
  class A
  {
      public String name = “”;
  }
  public class T1 extends Test
  {
      private void t(A a)
      {
          // 如果不加这句
          // a = new A();
          // main方法中对象实例a的name值将会被修改
          // 最后会都输出”t的方法”
          a = new A();
          a.name = “t的方法”;
          System.out.println(“t.a == ” + a.name);
      }    
      public static void main(String[] args)
      {
          T1 t = new T1();
          A a = new A();
          a.name = “main的方法”;
          t.t(a);
          System.out.pritnln(“main.a == ” + a.name);
      }
  }
  输出：
  t的方法
  main的方法

12.初始化子类必先初始化父类
   构造方法不能被继承

13.super 关键字的功能
   （1）点取父类中被子类隐藏了的数据成员
   （2）点取已覆盖了的方法
   （3）作为方法名表示父类构造方法
   对 super 的调用必须是构造方法的第一个语句
   无论是 super 还是 this 都必须放在构造函数的第一行

14.编译时看数据类型，运行时看实际的对象类型（new操作符后跟的构造方法是哪个类的）。
   一句话：new谁就调用谁的方法。

15.覆盖方法的规则
   （1）覆盖方法的返回类型，方法名称，参数列表必须与它所覆盖的方法相同
   （2）覆盖方法不能比它所覆盖的方法的访问性差，即访问权限不允许缩小
   （3）覆盖方法不能比它所覆盖的方法抛出更多的异常

16.重载：方法名相同，参数列表不同
     参数列表不同包括：个数不同，类型不同，顺序不同等等
     构造方法也可以重载
     public void t1(int a) {}
     public int t1() {}
     方法重载的返回类型可以相同也可以不同。

17.instanceof 运算符的功能
   用来判断实例变量是否属于某种类的类型

18.多态类型的强制转换
   向上强制类型转化类层次总是允许的，而且事实上不需要强制类型转换运算符。可由简单的赋值实现。
   严格讲，不存在向下类型转换。

19.static 属性的内存分配
   一个类中，一个 static 变量只会有一个内存空间，虽然有多个类实例，
   但这些类实例中的这个 static 变量会共享一个内存空间。

20.static 的变量是在类装载的时候就会被初始化。

21.static 的基本准则
   （1）一个类的静态方法只能访问静态属性
   （2）一个类的静态方法不能够直接调用非静态方法
   （3）若访问控制权限允许，static 属性和方法可以使用对象名家‘.’方式调用；
        当然也可以使用实例加‘.’方式调用
   （4）静态方法中不存在当前对象，因而不能使用“this”，当然也不能使用“super”
   （5）静态方法不能被非静态方法覆盖
   （6）构造方法不允许声明为static的
    注：非静态变量只属于实例，并只能通过实例应用被访问。
    
22.final 修饰符：在java中申明类、属性和方法时，可使用关键字final来修饰。final所标记的
   成分具有“终态”的特征，表示最终的意思。
   
23.final 的具体规则：
   （1）final 标记的类不能被继承
   （2）final 标记的方法不能被子类重写
   （3）final 标记的变量（成员变量或局部变量）只能赋值一次
   （4）final 标记的成员变量必须在声明的同事赋值，如果在声明的时候没有赋值，那么只有一次
       赋值的机会，而且只能在构造方法中显示赋值，然后才能使用。
   （5）final 标记的局部变量可以只声明不赋值，然后再进行一次性的赋值
   （6）final 一般用于标记那些通用性的功能、实现方式或取值不能随意更改的成分，以避免被误用
   
24.static 不能修饰局部变量，final可以（包括参数列表）。
     （3）“==”进行比较的时候，引用类型数据比较的是引用，及内存地址，基本数据类型比较
                 的是值。

25.（1）如果将引用类型（即，任何类的类型）的变量标记为 final，那么该变量不能指向任何其他
       象。但可以改变对象的内容，因为只有引用本身是 final 的。
   （2）final 除了可以使用在类定义、属性上、方法上之外，还可以用于方法内部，比如参数列表
           或者局部变量都是可以的。
           
26.由于String类值的不可变性，当String变量需要经常变换其值时，应该考虑使用StringBuffer
   或StringBuilder类，以提高程序效率。
   
27.数组的静态性：数组一旦被创建，就不能更改数组的长度。

28.equals方法：Object类定义的equals方法用于判别某个指定的对象与当前对象（调用
     equals方法的对象）是否等价。数据等价的基本含义是指两个数据的值相等。
    
29.equals方法与“==”运算符的关系
     （1）equals()方法只能比较引用类型，“==”可以比较引用类型及基本类型
     （2）默认的equals()方法比较的是内存地址，基本等同于“==”，但对于File、String、
              Date及包装类来说，是比较的值而不是内存地址
     （3）“==”进行比较的时候，引用类型数据比较的是引用，及内存地址，基本数据类型比较
                 的是值。
                 
30.覆盖equals方法的一般步骤如下：
     （1）用==检查是否参数就是这个对象的引用
     （2）判断要比较的对象是否为null，如果是null，返回false
     （3）用instanceof判断参数的类型是否正确
     （4）把参数转换城合适的类型
     （5）比较对象属性值是不是匹配
    
31.覆盖equals方法一定要连带覆盖hashCode方法

32.对于经常要改变值的字符串应该使用StringBuffer和StringBuilder类，这两个类功能基本
     相似，区别主要在于StringBuffer类的方法是多线程安全的，而StringBuilder不是线程安
     全的，相比而言StringBuilder类会略微快一点。
    
33.抽象类简单来说，使用abstract修饰的类就是抽象类。
    abstract 修饰符可以与类和方法一起使用。被修饰的类不能被实例化，被修饰的方法必须在包
    含此方法的类的子类中被实现。
    public abstract class Test{    //抽象类定义
        public abstract void doItByHand();    // 抽象方法定义
    }      
    
34.有抽象方法的类一定是抽象类，抽象类不一定有抽象方法。

35.不能有抽象构造方法或抽象静态方法。abstract 类的子类为它们父类中的所有抽象方法提供实现，
    否则它们也是抽象类。
    
36.在下列情况下，一个类将成为抽象类：
    （1）当一个类的一个或多个方法是抽象方法时;
    （2）当类是一个抽象类的子类，并且不能为任何抽象方法提供所有实现细节或方法主体时；
    （3）当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法主体时；

37.接口是一种特殊的抽象类，这种抽象类只包含常亮和方法的定义，而为没有变量和方法的实现。
    定义接口的语法格式：
    访问修饰符 修饰符 interface 接口名称
    {
        抽象属性集
        抽象方法集
    }
    
38.    （1）接口中声明的属性默认为，也只能是 public static final 的， 因而在常量声明时可以省略这些修饰符
    （2）接口中只能定义抽象方法，这些方法默认为 public abstract 的、也只能是 public abstract 的，
        因而在声明方法时可以省略这些修饰符
    （3）和继承抽象方法类似，Java类可以“实现”接口
    
39.    接口可以多继承

40.接口的基本作用
    （1）声明方法，期望一个或更多的类来实现该方法。
    （2）揭示一个对象的编程接口，而不揭示类的实际程序体。
    （3）捕获无关类之间的相似性，而不强迫类关系。
    （4）可以作为参数被传递到在其它对象上的调用方法中
    
41.多重接口：
    一个类实现多个接口就被称为多重接口。
    一个类只可以继承一个父类，但可以实现多个接口。
    类不可以多继承，因为两个父类的变量和方法可能重复。而接口不会继承变量，即便两个接口方法定义相同，
    接口中没有方法实现，类中也只有一个方法实现。
    
42.接口和抽象类的选择
    （1）优先选用接口，尽量少用抽象类
    选择抽象类的时候通常在如下情况：
    （2）需要定义子类的行为，有要为子类提供共性的功能。
    
43.try {} catch {} 的语法
    try {
        // 可能出错的代码
    } catch (异常类型 e) {
        // 异常处理代码
    }
    
44.当多个catch块存在的时候，从上往下catch异常的范围应该从小到大，因为catch块的运行机制是找到一个
    匹配的就进行处理，如果把范围大的放在前面，那么后面的代码就没有机会运行了，这会是一个编译异常。
    
45.finally 块
    （1）finally 块：无论是否出现异常，都会运行的块。
    （2）通常在 finally 块中可以编写资源返回给系统的语句，通常这些语句包括但不限于：
        1.释放动态分配的内存块
        2.关闭文件
        3.关闭数据库结果集
        4.关闭与数据库建立的连接
    finally 紧跟这最后一个块，是可选的，不论是否抛出异常， finally块总会被执行。
    语法如下：
    try{
    }catch(异常类型 e)
    {
    }finally{
    }
    
46.try、catch、finally 块的关系
    （1）try 块不能单独存在，后面必须跟 catch 块或者 finally 块
    （2）三者之间的组合为： try – catch、 try – catch – finally、 try – finally
    （3）一个 try 块可以有多个 catch 块，从上到下多个 catch 块的范围为从小到大
    
47.throw 语句用来从代码中主动抛出异常。throw 的操作数是人一种异常类对象。下面是 throw 关键字的一
    个示例：
    try{
        int i = 5/0;
    } catch (ArithmeticException i) {
        throw new Exception (“Can not be divided by zero!”);
    }
    
48.throws 语句
    （1）throws 用来在方法定义时声明异常，其后列出了此方法可能抛出的异常列表。
    （2）Java中对异常的处理有两种方法，一个就是 try – catch, 然后自己处理；一个就是不做处理，
        向外 throws，由别人去处理。
    public static void main(String[] args) throws Exception {}