JAVA基础小结（一）

一、修饰符

1.访问控制修饰符

1. default(即缺省，什么也不写)：在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
2. private:在同一类中可见。使用对象：变量、方法。
3. public：对所有类可见。使用对象：类、接口、变量、方法。
4. protected：对同一包内的类和所有子类可见。使用对象：变量和方法。注意不能修饰类（外部类）。

小结：

1. 权限级别：public>protected>defalut>private.
2. 使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。
3. 接口里的变量都隐式声明为public static final
4. 接口里的方法默认情况下访问权限为public.
5. 类和接口不能声明为private.
6. protected访问修饰符不能修饰类和接口，方法和成员变量能够声明为protected，但是接口的成员变量和成员方法不能声明为protected.

2.继承规则

1. 父类中声明为public的方法在子类中也必须为public.
2. 父类中声明为protected的方法在子类中要么声明为protected，要么声明为public，不能声明为private。

3.非访问控制修饰符

3.1static修饰符

1. 用来修饰类方法和类变量
2. 对类变量和方法的访问可以直接使用classname.variblename和classname.methodname方式访问。

3.1.1 静态变量

    static关键字用来声明独立于对象的静态变量，无论一个类实例化多少个对象，它的静态变量只有一份拷贝，静态变量也被称为类变量。局部变量不能被声明为static变量。

3.1.2 静态方法

    static关键字用来独立于对象的静态方法。静态不能使用类的非静态变量。静态方法从参数列表得到的数据，然后计算这些数据。

3.2 final修饰符

1. 用来修饰类、方法和变量
2. final修饰的类不能被继承
3. 修饰的方法不能被继承类重新定义。
4. 修饰的变量为常量，是不可修改的。

3.2.1final变量：

1. final变量能被显示地初始化并且只能初始化一次。
2. 被声明为final的对象的引用不能指向不同的对象。
3. 但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但是引用对象里面的内容可以改变。如：

4. /**
    * final修饰符
    * Created by chen on 2018/1/7.
    */
   public class Modifler {
       //final修饰基本类型的变量
       public static final char CHAR = '中';
       public static final Integer NUM = 123;
   
       //final修饰引用类型的变量
       public static final StringBuffer sb = new StringBuffer("StringBuffer");
       public static final Student student = new Student("Tom",88);
   
       public static void main(String[] args) {
           //问题1：使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变
           //Modifler.NUM = 234;//编译报错，引用不能变
           //Modifler.CHAR='国';//编译报错，引用不能变
   
           System.out.println("Modifler.sb old:" + Modifler.sb);
           Modifler.sb.append("Modifiler");
           System.out.println("Modifler.sb.toString() = " + Modifler.sb.toString());
           System.out.println(" =========================================== " );
           //答案：使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的
   
           //再看一个例子：
           System.out.println("Modifler.student old = " + Modifler.student.toString());
           Modifler.student.setName("Jeff");
           Modifler.student.setScore(59);
           System.out.println("Modifler.student new = " + Modifler.student.toString());
       }
   }
   
   输出：
   Modifler.sb old:StringBuffer
   Modifler.sb.toString() = StringBufferModifiler
    =========================================== 
   Modifler.student old = Student: Tom 88
   Modifler.student new = Student: Jeff 59
   
   Process finished with exit code 0

3.2.2 final方法：

1. 类中的final方法可以被子类继承，但是不能被子类修改。
2. 声明final方法的主要目的是防止该方法的内容被修改。

3.2.3 final类

    final类不能被继承，没有类能够继承final类的任何特性。

3.3 abstract修饰符

3.3.1抽象类

1. 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩展。
2. 一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类必须声明来抽象类，否则将出现编译错误。
3. 抽象类可以包含抽象方法和非抽象方法。

3.4 synchronize修饰符

二、Java序列化与反序列化

 

转载于:https://my.oschina.net/u/998410/blog/1603550