Java复习笔记

java是一门很好的语言,也是一门庞杂的系统,学习过程中要善于记录和积累。 

学习了四年java,但回头看看好像什么都没学到,是因为学习没有成系统,知识没有成系统。

面向对象编程有很多重要的特性

比如:封装,继承,多态和抽象。下面的章节我们会逐个分析这些特性。

封装

封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在Java当中,有3种修饰符:public,private和protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。

下面列出了使用封装的一些好处:

  • 通过隐藏对象的属性来保护对象内部的状态。
  • 提高了代码的可用性和可维护性,因为对象的行为可以被单独的改变或者是扩展。
  • 禁止对象之间的不良交互提高模块化。

继承

继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行,也可以在不修改类的情况下给现存的类添加新特性。Java不支持多继承。每个类都只能继承一个类,但是可以实现多个接口。

在java中:
多态,是 面向对象的程序设计语言最核心的特征。多态,意味着一个对象有着多重特征,可以在特定的情况下,表现不同的状态,从而对应着不同的属性和方法。从程序设计的角度而言,多态可以这样来实现(以 java语言为例):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public  interface Parent //父类接口
{
     public  void  simpleCall();
}
public  class  Child_A implements Parent
{
     public  void  simpleCall();
     {
     //具体的实现细节;
     }
}
 
public  class  Child_B implements Parent
{
     public  void  simpleCall();
     {
     //具体的实现细节;
     }
}
//当然还可以有其他的实现
然后,我们就可以看到多态所展示的特性了:
Parent pa = new Child_A();
pa.simpleCall()则显然是调用Child_A的方法;
Parent pa = new Child_B();
pa.simpleCall()则是在调用Child_B的方法。所以,我们对于抽象的父类或者接口给出了我们的具体实现后,pa 可以完全不用管实现的细节,只访问我们定义的方法,就可以了。事实上,这就是多态所起的作用,可以实现 控制反转这在大量的J2EE 轻量级框架中被用到,比如Spring的依赖注入机制。

抽象

抽象是把想法从具体的实例中分离出来的步骤,因此,要根据他们的功能而不是实现细节来创建类。Java支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。

抽象和封装的不同点

抽象和封装是互补的概念。一方面,抽象关注对象的行为。另一方面,封装关注对象行为的细节。一般是通过隐藏对象内部状态信息做到封装,因此,封装可以看成是用来提供抽象的一种策略。



java虚拟机:jvm可以执行java字节码(java源文件被编译成字节码文件),可以使java运行在任意平台,不需要程序员为每一个平台重写代码重新编译。

jdk和jre:java开发工具包(包含jre编译器和其他工具),java运行环境。


java中的static的作用;(可以在没有实例化的情况下被访问)

是静态修饰符,什么叫静态修饰符呢?大家都知道,在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的,而所谓静态就是指在编译后所分配的内存会一直存在,直到程序退出内存才会释放这个空间,也就是只要程序在运行,那么这块内存就会一直存在。这样做有什么意义呢? 
在Java程序里面,所有的东西都是对象,而对象的抽象就是类,对于一个类而言,如果要使用他的成员,那么普通情况下必须先实例化对象后,通过对象的引用才能够访问这些成员,但是有种情况例外,就是该成员是用static声明的(在这里所讲排除了类的访问控制),例如: 
未声明为static 
class ClassA{ 
int b; 
public void ex1(){ 
… 
} 
} 
class ClassB{ 
void ex2{ 
int i; 
ClassA a = new ClassA(); 
i = a.b; //这里通过对象引用访问成员变量b 
a.ex1; //这里通过对象引用访问成员函数ex1 
} 
} 

声明为static 
class ClassA{ 
static int b; 
static void ex1(){ 
… 
} 
} 
class ClassB{ 
void ex2{ 
int i; 
i = ClassA.b; //这里通过类名访问成员变量b 
ClassA.ex1; //这里通过类名访问成员函数ex1 
} 
} 
通过以上两种比较,就可以知道static用来修饰类成员的主要作用了,在java类库当中有很多类成员都声明为static,可以让用户不需要实例化对象就可以引用成员,最基本的有Integer.parseInt(),Float.parseFloat()等等用来把对象转换为所需要的基本数据类型。这样的变量和方法我们又叫做类变量和类方法。 
接下来讲一下被static修饰后的变量的值的问题,刚才在前面讲过,被static修饰后的成员,在编译时由内存分配一块内存空间,直到程序停止运行才会释放,那么就是说该类的所有对象都会共享这块内存空间,看一下下面这个例子: 
class TStatic{ 
static int i; 

public TStatic(){ 
i = 4; 
} 

public TStatic(int j){ 
i = j; 
} 

public static void main(String args[]){ 
TStatic t = new TStatic(5); //声明对象引用,并实例化 
TStatic tt = new TStatic(); //同上 
System.out.println(t.i); 
System.out.println(tt.i); 
System.out.println(t.i); 
} 
} 
这段代码里面Tstatic类有一个static的int变量I,有两个构造函数,第一个用于初始化I为4,第二个用于初始化i为传进函数的值,在main中所传的值是5,程序首先声明对象的引用t,然后调用带参数的构造函数实例化对象,此时对象t的成员变量I的值为5,接着声明对象tt,调用无参数的构造函数,那么就把对象tt的成员变量i的值初始化为4了,注意了,在这里i是static,那就是说该类的所有对象都共享该内存,那也就是说在实例化对象tt的时候改变了i的值,那么实际上对象t的i值也变了,因为实际上他们引用的是同一个成员变量。最后打印的结果是三个4。
Java中static方法不能被覆盖,因为方法覆盖是基于运行时动态绑定的,而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关,所以概念上不适用。

java中的自动装箱和拆箱:(基本数据类型和对象包装类型)
  • byte
  • short
  • int
  • long
  • float
  • double
  • boolean
  • char

自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如:把int转化成Integer,double转化成double,等等。反之就是自动拆箱。

java的方法重载、方法覆盖和构造函数:
Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。(体现了多态性)与此相对,方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名,参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。

当新对象被创建的时候,构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下,Java编译器会为这个类创建一个默认的构造函数。

Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。


抽象类和接口:
接口和抽象类的定义类似、区别是:一个类实现接口、必须实现接口里的所有方法、而且一个类可以实现多个接口(相当于多继承)接口使用interface关键字、而抽象类使用的是abstract 关键字、一个类只能继承一次。继承抽象类的话、是可以不全部实现他的所有方法的。但是你可以重写他的方法

接口和抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。

抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类(如果是类的话……),他们的抽象类是人。说明,他们都是人。

人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些类去实现它.

所以,在高级语言上,一个类只能继承一个类(抽象类)(正如人不可能同时是生物和非生物),但是可以实现多个接口(吃饭接口、走路接口)。

第一点. 接口是抽象类的变体,接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。 第二点. 接口可以多继承,抽象类不行 第三点. 接口定义方法,不能实现,而抽象类可以实现部分方法。 第四点. 接口中基本数据类型为static 而抽类象不是的。

当你关注一个事物的本质的时候,用抽象类;当你关注一个操作的时候,用接口。


抽象类的功能要远超过接口,但是,定义抽象类的代价高。因为高级语言来说(从实际设计上来说也是)每个类只能继承一个类。在这个类中,你必须继承或编写出其所有子类的

所有共性。虽然接口在功能上会弱化许多,但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。


进程和线程:
线程是系统中执行的最小单元,同一进程中有许多线程,线程共享进程的资源。
创建线程的方法:
1.实现Thread类
2.实现Runnable接口

  • 3.应用程序可以使用Executor框架来创建线程池

 线程执行过程中的几种状态:
  • 就绪(Runnable):线程准备运行,不一定立马就能开始执行。
  • 运行中(Running):进程正在执行线程的代码。
  • 等待中(Waiting):线程处于阻塞的状态,等待外部的处理结束。
  • 睡眠中(Sleeping):线程被强制睡眠。
  • I/O阻塞(Blocked on I/O):等待I/O操作完成。
  • 同步阻塞(Blocked on Synchronization):等待获取锁。
  • 死亡(Dead):线程完成了执行。
java中的集合类:

Java集合类提供了一套设计良好的支持对一组对象进行操作的接口和类。Java集合类里面最基本的接口有:

  • Collection:代表一组对象,每一个对象都是它的子元素。
  • Set:不包含重复元素的Collection。
  • List:有顺序的collection,并且可以包含重复元素。
  • Map:可以把键(key)映射到值(value)的对象,键不能重复。

.数组(Array)和列表(ArrayList)有什么区别?什么时候应该使用Array而不是ArrayList?

下面列出了Array和ArrayList的不同点:

  • Array可以包含基本类型和对象类型,ArrayList只能包含对象类型。
  • Array大小是固定的,ArrayList的大小是动态变化的。
  • ArrayList提供了更多的方法和特性,比如:addAll(),removeAll(),iterator()等等。
  • 对于基本类型数据,集合使用自动装箱来减少编码工作量。但是,当处理固定大小的基本数据类型的时候,这种方式相对比较慢。

ArrayList和LinkedList有什么区别?

ArrayList和LinkedList都实现了List接口,他们有以下的不同点:

  • ArrayList是基于索引的数据接口,它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应,LinkedList是以元素列表的形式存储它的数据,每一个元素都和它的前一个和后一个元素链接在一起,在这种情况下,查找某个元素的时间复杂度是O(n)。

  • 相对于ArrayList,LinkedList的插入,添加,删除操作速度更快,因为当元素被添加到集合任意位置的时候,不需要像数组那样重新计算大小或者是更新索引。

  • LinkedList比ArrayList更占内存,因为LinkedList为每一个节点存储了两个引用,一个指向前一个元素,一个指向下一个元素。





  • HashSet和TreeSet有什么区别?

  • HashSet是由一个hash表来实现的,因此,它的元素是无序的。add(),remove(),contains()方法的时间复杂度是O(1)。

    另一方面,TreeSet是由一个树形的结构来实现的,它里面的元素是有序的。因此,add(),remove(),contains()方法的时间复杂度是O(logn)。


Comparable和Comparator接口是干什么的?列出它们的区别。

Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说,它返回负数,0,正数来表明输入对象小于,等于,大于已经存在的对象。

Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序,返回负数,0,正数表明第一个参数是小于,等于,大于第二个参数。equals()方法需要一个对象作为参数,它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候,这个方法才返回true。

java中的垃圾回收机制:

http://blog.csdn.net/zsuguangh/article/details/6429592

意义:除了释放没用的对象,垃圾回收也可以清除内存记录碎片

Java的垃圾回收机制是JVM提供的能力,用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。
需要注意的是:垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身
System.gc()
Runtime.getRuntime().gc()  
上面的方法调用时用于显式通知JVM可以进行一次垃圾回收,但真正垃圾回收机制具体在什么时间点开始发生动作这同样是不可预料的,这和抢占式的线程在发生作用时的原理一样。

finalize()方法什么时候被调用?析构函数(finalization)的目的是什么?

在释放对象占用的内存之前,垃圾收集器会调用对象的finalize()方法。一般建议在该方法中释放对象持有的资源。


java面试/笔试题:

面哪个流类属于面向字符的输入流(  )

A  BufferedWriter           B  FileInputStream          C  ObjectInputStream          D  InputStreamReader

 答案:D

 解析:Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
面向字节的操作为以8位为单位对二进制的数据进行操作,对数据不进行转换,这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作,在读的时候将二进制数据转为字符,在写的时候将字符转为二进制数据,这些类都是Reader和Writer的子类。

总结:以InputStream(输入)/OutputStream(输出)为后缀的是字节流;

          以Reader(输入)/Writer(输出)为后缀的是字符流。

扩展:Java流类图结构,一目了然,解决大部分选择题:

 

Java复习笔记_第1张图片


 Java接口的修饰符可以为()

A private     B protected     C final       D abstract

答案:CD

解析:接口很重要,为了说明情况,这里稍微啰嗦点:

(1)接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部使用者能访问它们;

(2)接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法;

(3)接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量,只有静态(static)变量;

(4)接口的中的变量是所有实现类共有的,既然共有,肯定是不变的东西,因为变化的东西也不能够算共有。所以变量是不可变(final)类型,也就是常量了。

(5) 接口中不可以定义变量?如果接口可以定义变量,但是接口中的方法又都是抽象的,在接口中无法通过行为来修改属性。有的人会说了,没有关系,可以通过 实现接口的对象的行为来修改接口中的属性。这当然没有问题,但是考虑这样的情况。如果接口 A 中有一个public 访问权限的静态变量 a。按照 Java 的语义,我们可以不通过实现接口的对象来访问变量 a,通过 A.a = xxx; 就可以改变接口中的变量 a 的值了。正如抽象类中是可以这样做的,那么实现接口 A 的所有对象也都会自动拥有这一改变后的 a 的值了,也就是说一个地方改变了 a,所有这些对象中 a 的值也都跟着变了。这和抽象类有什么区别呢,怎么体现接口更高的抽象级别呢,怎么体现接口提供的统一的协议呢,那还要接口这种抽象来做什么呢?所以接口中 不能出现变量,如果有变量,就和接口提供的统一的抽象这种思想是抵触的。所以接口中的属性必然是常量,只能读不能改,这样才能为实现接口的对象提供一个统 一的属性。

通俗的讲,你认为是要变化的东西,就放在你自己的实现中,不能放在接口中去,接口只是对一类事物的属性和行为更高层次的抽象。对修改关闭,对扩展(不同的实现 implements)开放,接口是对开闭原则的一种体现。

所以:

接口的方法默认是public abstract;

接口中不可以定义变量即只能定义常量(加上final修饰就会变成常量)。所以接口的属性默认是public static final 常量,且必须赋初值

注意:final和abstract不能同时出现。

 

不通过构造函数也能创建对象吗()

A 是     B 否

答案:A

解析:Java创建对象的几种方式(重要):

(1) 用new语句创建对象,这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段,调用java.io.ObjectInputStream对象的 readObject()方法。

(1)和(2)都会明确的显式的调用构造函数 ;(3)是在内存上对已有对象的影印,所以不会调用构造函数 ;(4)是从文件中还原类的对象,也不会调用构造函数。

下面程序能正常运行吗()

复制代码
public class NULL {

    public static void haha(){
        System.out.println("haha");
    }
    public static void main(String[] args) {
        ((NULL)null).haha();
    }

}
复制代码

答案:能正常运行

解析:输出为haha,因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象,其返回值还是为null,而static方法的调用是和类名绑定的,不借助对象进行访问所以能正确输出。反过来,没有static修饰就只能用对象进行访问,使用null调用对象肯定会报空指针错了。这里和C++很类似。这里感谢@Florian网友解答。


下面程序的运行结果是什么()

复制代码
class HelloA {

    public HelloA() {
        System.out.println("HelloA");
    }
    
    { System.out.println("I'm A class"); }
    
    static { System.out.println("static A"); }

}

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }
    
    { System.out.println("I'm B class"); }
    
    static { System.out.println("static B"); }
    
    public static void main(String[] args) {

        System.out.println("-------main start-------");
        new HelloB();
        new HelloB();
        System.out.println("-------main end-------");
    }
}
复制代码

此时输出结果为:

复制代码
static A
static B
-------main start-------
I'm A class
HelloA
I'm B class
HelloB
I'm A class
HelloA
I'm B class
HelloB
-------main end-------
复制代码

解析:说实话我觉得这题很好,考查静态语句块、构造语句块(就是只有大括号的那块)以及构造函数的执行顺序。

对象的初始化顺序:(1)类加载之后,按从上到下(从父类到子类)执行被static修饰的语句;(2)当static语句执行完之后,再执行main方法;(3)如果有语句new了自身的对象,将从上到下执行构造代码块、构造器(两者可以说绑定在一起)。


选项中哪一行代码可以替换题目中//add code here而不产生编译错误?(

复制代码
public abstract class MyClass {
public int constInt = 5; //add code here public void method() { } }
复制代码

Apublic abstract void method(int a);

B constInt = constInt + 5;

public int method();

public abstract void anotherMethod() {}

答案:A

解析:考察抽象类的使用。

抽象类遵循的原则:

(1)abstract关键字只能修饰类和方法,不能修饰字段。
(2)抽象类不能被实例化(无法使用new关键字创建对象实例),只能被继承。
(3)抽象类可以包含属性,方法,构造方法,初始化块,内部类,枚举类,和普通类一样, 普通方法一定要实现,变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量(只能在子类中改变该变量)。
(4)抽象类中的抽象方法(加了abstract关键字的方法)不能实现。
(5)含有抽象方法的类必须定义成抽象类。
 
扩展:抽象类和接口的区别,做个总结吧:

(1)接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的。

(2)abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface,实现多重继承。接口还有标识(里面没有任何方法,如Remote接口)和数据共享(里面的变量全是常量)的作用。

(3)在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是 static final的,不过在 interface中一般不定义数据成员),所有的成员方法默认都是 public abstract 类型的。

(4)abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"has-a"关系。

(5)实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。

(6)接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以在子类中重新赋值。


你可能感兴趣的:(Java复习笔记)