Java基础知识(一)

1，Java程序初始化顺序
父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量、父类非静态代码块、父类构造函数、子类非静态变量、子类非静态代码块、子类构造函数。

2，Java中的作用域有哪些
public、protected、default、private。

3，一个Java文件中是否可以定义多个类
一个Java文件中可以定义多个类，但 最多只能有一个类被public修饰，且这个类的类名与文件名必须相同。

4，构造函数
1）构造函数必须与类名相同，且没有返回值
2）每个类可以有多个构造函数，编译器会默认提供一个没有参数的构造函数，若开发人员提供了构造函数，则编译器就不会再创建默认的构造函数了。
3）构造函数可以有0个、1个或多个参数。
4）构造函数只能通过new 调用
5）构造函数的主要作用是完成对象的 初始化工作
6）构造函数不能被继承，它不能被覆盖，但可以被重载，可以使用不同的参数个数或参数类型来定义多个构造函数。
7）子类可以通过super关键字来显示地调用父类的构造函数，当有父类时，在实例化对象时会先执行父类的构造函数，然后执行子类的构造函数。

5，Java中clone 方法有什么作用
Java在处理基本数据类型（如int、byte、char等），都是采用按值传递（传递的是输入参数的复制）的方式执行，除此之外的其他类型都是按引用传递（传递的是对象的一个引用）的方式执行。对象除了在函数调用时是引用传递，在使用“=”赋值时也采用引用传递。

Java中的所有类默认都继承自Object类，而Object类中提供了一个clone()方法，这个方法的作用是返回一个Object对象的复制，这个复制函数返回的是一个新的对象而不是一个引用。

使用clone()方法的步骤：
1）实现clone类首先需要继承Cloneable接口，
2）在类中重写Object类中的clone()方法
3）在clone方法中调用super.clone()。
4）吧浅复制的引用指向原型对象新的克隆体。

引用：

Obj a=new Obj();Obj b=a;

clone

Obj a=new Obj();Obj b=(Obj)a.clone();public Object clone(){    Object o=null;    try{        o=(Obj)super.clone();    }catch(Exception e){        e.printStackTrace();    }    return o;}

首先，检查类有没有非基本类型（即 ，对象的数据成员，若没有，则返回super.clone()即可； 若有，确保类中包含的所有非基本类型的成员变量都实现了深复制）

Object o=super.clone();//先执行浅复制对每一个对象attr执行以下语句：o.attr =this.getAttr().clone();最后返回o

浅复制和深复制的区别：
浅复制：浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
深复制： 被复制对象的所有变量都含有与原来对象相同的值，出去哪些引用其他对象的变量。深复制把复制的对象所引用的对象都复制了一遍。

6，什么是反射机制？
反射机制：得到一个对象所属的类；获取一个类的所有成员变量和方法；在运行时创建对象；在运行时调用对象的方法，
可以在运行时动态的创建类的对象。

package Java基础知识;class Base{    public void f(){        System.out.println("Base");    }}class Sub extends Base{    public void f(){        System.out.println("Sub");    }}public class Java反射机制 {    @SuppressWarnings("rawtypes")    public static void main(String[] args) throws InstantiationException, IllegalAccessException {        // TODO Auto-generated method stub        try{            Class c=Class.forName("Sub");            或者 =Sub.class            或者 =new Sub().getClass()            Base b=(Base)c.newInstance();            b.f();        }catch(ClassNotFoundException e){            e.printStackTrace();        }    }}

3中方法获取class类：
1）Class.forName(“类的路径”)
2）类名.class
3) 实例.getClass()

Java创建对象的4中方式：
1）通过new 实例化一个对象
2）通过反射机制创建对象

即 Class c = Class.forName("类的路径") 类名.class  实例.getClass();  然后 Base b=(Base)c.newInstance(); 

3）通过clone()方法创建一个对象。
Obj a=new Obj();
Obj b=(Obj)a.clone();
4) 通过反序列化的方式创建对象

面向对象：
站在抽象的角度：人具有身高、体重等属性，人会行走、吃饭等方法，人是一个抽象的概念，每个实实在在的人都是人的一个对象而已。。

多态：
1，方法的重载 overload 重载： 同一个类中有多个同名的方法，这些方法有着不同的参数，在编译时确定到底调用哪个方法，编译时多态。例如： 不同的参数个数、不同的参数类型、不同的参数顺序。
2，方法的复写 override 运行时多态。同样的方法在父类与子类中有着不同的表现形式。
而且：只有类中的方法才有多态的概念，类中的成员变量没有多态的概念。
eg:

package Java基础知识;class Base1{    public Base1(){        g();    }    public void f(){        System.out.println("Base f()");    }    public void g(){        System.out.println("Base f()");    }}class Derived extends Base1{    public void f(){        System.out.println("Derived f()");    }    public void g(){        System.out.println("Derived g()");    }}public class 多态 {    public static void main(String[] args) {        // TODO Auto-generated method stub        Base1 b= new Derived();        b.f();        b.g();    }}输出：Derived g()Derived f()Derived g()Base b=new Derived();b.f();b.g();//而类的方法，则会呈现多态性。Base b=new Derived();System.out.println(b.i);//成员变量的值取决于所定义变量的类型，即成员变量 i 的值取b的类型的值即Basepackage Java基础知识;class Base1{    public int i=1;}class Derived extends Base1{    public int i=2;}public class 多态 {    public static void main(String[] args) {        // TODO Auto-generated method stub        Base1 b= new Derived();        System.out.println(b.i);    }}输出：1

7，抽象类和接口
接口中定义的成员变量 默认为public static final ，只能够有静态的不能被修改的数据成员，而且必须给其赋初值，接口所有的成员方法都是public、abstract的。且只能被这两个关键字修饰。

抽象类可以有自己的数据成员变量，也可以有非抽象的成员方法。
抽象类中的抽象方法前面有abstract修饰，且不能用private、static、synchronized、native等修饰，因为需要被子类继承，且抽象方法必须以分号结尾，并且不带花括号。

8，内部类
4种： 静态内部类、成员内部类、局部内部类、匿名内部类。

class outerClass{    static class innerClass{} //静态内部类}class outerClass{    class innerClass{}//成员内部类（普通内部类）}class outerClass{    public void menberFunction(){        class innerClass(){}//局部内部类    }}public class myFrame extends Frame{//外部类    public myFrame(){        addWindowListener(new WindowAdapter(){//匿名内部类            public void windowClosing(WindowEvent e){                dispose();                System.exit(0);            }        })      }}

如何获取父类的类名

this.getClass().getSuperclass().getName();不能使用super.getClass().getName();//这是因为Java中任何类都继承自Object类，getClass()方法在Object中被定义为final 与 native，子类不能覆盖该方法，因此this.getClass()和super.getClass()最终都调用的是Object中的getClass()方法。利用Java的反射机制，使用getClass().getSuperclass().getName()来获取父类的名字  。

super()、this()调用其他的类构造函数时，必须为构造函数中的第一条语句！！
标识符的第一个字符必须是字符、下划线或$。且标识符不能包含空白字符(换行符、空格和制表符)

final指的是引用的不变性，即它只能指向初始时指向的那个对象，而不关心指向对象内容的变化。

static关键字的作用：
4中使用情况：成员变量、成员方法、代码块、内部类。

1）static成员变量：
static修饰的静态变量只有一份，所有对象共享这个静态变量。
2）static成员方法：
static方法中不能使用this和super关键字，不能调用非static方法和非static变量，只能访问所属类的静态成员变量和静态成员方法。因为，当static方法被调用时，这个类的对象可能还没有被创建。
3）static静态代码块
JVM在加载类时会执行static代码块，若有多个static代码块，则按顺序执行。static代码块常用来初始化静态变量。static代码块只会被执行一次。
4）static静态内部类
它可以不依赖于外部类实例对象而被实例化，而通常的内部类需要在外部类实例化后才能实例化。

switch
switch参数只能是枚举常量或者整型（或者能够被隐式转换为int类型或者对应的包装类Integer，如 byte、short、char）

volatile
可见性，不保证原子性，系统每次用到它时都是直接从对应的内存中提取，而不会利用缓存，在使用volatile修饰成员变量后，所有线程在任何时候所看到的变量的值都是相同的。

无符号右移>>>和>>的区别：
无符号右移>>>： 无论参与的数字为正数或负数，在执行运算时，都在高位补0.
而>>：若运算的数字为正数，则在高位补0；若为负数，则在高位补1.
左移<<没有 有符号与无符号左移之分。左移时，低位补0.