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的类型的值即Base
package 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.