接口中不能有构造方法,抽象类中可以有。抽象类中构造方法作用:初始化抽象类的成员;为继承它的子类使用

定义在同一个包(package)内的类是可以不经过import而直接相互使用

final修饰的方法可以被重载 但不能被重写

从设计层面来说,抽象类是对类的抽象,是一种模板设计,接口是行为的抽象,是一种行为的规范。

  • 进入DEAD的线程,它还可以恢复,GC不会回收

静态变量

下列代码输出什么

class HasStatic{
    private static int x = 100;
    public static void main(String args[ ]){
        HasStatic hs1 = new HasStatic();
        hs1.x++;
        HasStatic hs2 = new HasStatic();
        hs2.x++;
        hs1=new HasStatic();
        hs1.x++;
        HasStatic.x--;
        System.out.println( "x=" +x);
    }
}

答案:102

判断:

  • 在java中,我们可以用违例(Exception)来抛出一些并非错误的消息,但这样比直接从函数返回一个结果要更大的系统开销。

可以用违例(Exception)来抛出一些并非错误的消息,可以,并非错误的消息。比如我自定义一个异常,若一个变量大于10就抛出一个异常,这样就对应了B选项说的情况,我用抛出异常说明这个变量大于10,而不是用一个函数体(函数体内判断是否大于10,然后返回true或false)判断,因为函数调用是入栈出栈,栈是在寄存器之下的速度最快,且占的空间少,而自定义异常是存在堆中,肯定异常的内存开销大!所以B对。

javac

构造器

易错:超易错,

下面代码将在哪一处报错:

public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1)
    public static void main(String[] args) {
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}

答案:3)

构造方法就是:public 类名, 没有方法修饰符
所以 (1)  处就是一个普通方法
所以该类没有带参数构造方法 ,编译报错

易错2:

下面代码将输出什么

public class Test {
    public int aMethod(){
        static int i = 0;
        i++;
        return i;
    }
public static void main(String args[]){
    Test test = new Test();
    test.aMethod();
    int j = test.aMethod();
    System.out.println(j);
    }
}

答案:报错
静态变量只能在类主体中定义,不能在方法中定义


  • 子类不但可以继承父类的无参构造函数,也可以继承父类的有参构造函数。
    答案:x
构造函数不能被继承,构造方法只能被显式或隐式的调用。

如果说有参构造可以被继承,那么在子类中有参构造就可以被重写;那么就无法通过父类的有参构造创建对象了;所以有参构造不能被继承。

1.构造函数不能继承,只是调用而已;
2.若父类没有无参构造函数,则创建子类时,不能编译;除非在构造函数代码体中第一行,必须是第一行显示调用父类的有参构造函数;
3.若父类中没有任何构造函数,则系统会默认有一个无参构造函数

如果父类中只定义了有参数构造方法,jvm就不会隐式为父类创建无参数构造,那么,你在创建子类继承父类时,你的子类就必须调用父类中任何一个有参数构造进行初始化才行,如果,在你的子类中仅仅写个无参数构造,那么编译不通过

访问权限

  • 访问权限控制从最大权限到最小权限依次为:public、 包访问权限、protected和private 。
    答案:错
    public、protected、 包访问权限和private 。

下面代码运行结果是什么

public class Arraytest{
    int a[] = new int[6];
    public static void main ( String arg[] ) {
        System.out.println ( a[0] );
    }
}

答案: 编译错误
在static方法中是不能访问非静态变量 a 的,需要将 a 声明为static,答案才会是 0 ,否则是编译出错

匿名内部类

匿名内部类可以看这里,
– [ ] 匿名内部类不可以定义构造器

答案:✓

匿名内部类的创建格式为: new 父类构造器(参数列表)|实现接口(){
                                             //匿名内部类的类体实现
                                        }
使用匿名内部类时,必须继承一个类或实现一个接口
匿名内部类由于没有名字,因此不能定义构造函数
匿名内部类中不能含有静态成员变量和静态方法

Byte

下面代码输出什么:

public class Test2
{
    public void add(Byte b)
    {
        b = b++;
    }
    public void test()
    {
        Byte a = 127;
        Byte b = 127;
        add(++a);
        System.out.print(a + " ");
        add(b);
        System.out.print(b + "");
    }
}

答案:-128 127
解析:

包装类的值是final修饰不可变的,无论是++b还是b++都创建了一个新对象,那么作为参数传递时,形参和实参不会指向一个地址。也就是说,即使add() 方法中不是b = b++;这样没有意义的代码,传入参数的值也不会改变。

byte类型取值范围为-128~127,在a变量进行++a运算时,会导致a变为-128,这是因为整数在内存中使用的是补码的形式表示,最高位是符号位,0表示正数,1表示负数,加一导致补码进位,符号位变为1.

因此,本题正确输出为-128 127

左移右移

>>表示右移,如果该数为正,则高位补0,若为负数,则高位补1;
>>>表示无符号右移,也叫逻辑右移,即若该数为正,则高位补0,而若该数为负数,则右移后高位同样补0

运算符“>>”执行算术右移,它使用最高位填充移位后左侧的空位。

    右移的结果为:每移一位,第一个操作数被2除一次,移动的次数由第二个操作数确定。

逻辑右移或叫无符号右移运算符“>>>“只对位进行操作,没有算术含义,它用0填充左侧的空位。

算术右移不改变原数的符号,而逻辑右移不能保证这点。

移位运算符约简其右侧的操作数,当左侧操作数是int类型时,右侧以32取模;当左侧是long类型时,右侧以64取模。
>> 右移 高位补符号位
>>> 右移 高位补0
~~~ 逻辑左移时,最高位丢失,最低位补0;~~~
逻辑右移时,最高位补0,最低位丢失;
算术左移时,依次左移一位,尾部补0,最高的符号位保持不变。
算术右移时,依次右移一位,尾部丢失,符号位右移后,原位置上复制一个符号位;
循环左移时,将最高位重新放置最低位
循环右移时,将最低位重新放置最高位
例如:
1010100010101
~~逻辑左移一位结果为 0101000101010~~
逻辑右移一位结果为 0101010001010
算术左移一位结果为 1101000101010
算术右移一位结果为 1101010001010
循环左移一位结果为 0101000101011
循环右移一位结果为 1101010001010

总结的比较好的

java跨平台运行

write once,run everywhere 指的是编译后的字节码可以跨平台执行,也就是class文件,而不是Java源文件

is-a has-a like-a

is-a:继承关系 has-a:从属关系 like-a:组合关系
抽象类表示的是 is-a 关系;
接口表示的是 like-a 关系;

易错

package algorithms.com.guan.javajicu; 
public class Inc { 
    public static void main(String[] args) { 
       Inc inc = new Inc(); 
       int i = 0; 
       inc.fermin(i); 
       i= i ++; 
       System.out.println(i);

    } 
    void fermin(int i){ 
       i++; 
    } 
}

答案:0

第二弹

下面代码编译会报错吗?

public class Person{
    static int arr[] = new int[5];
    public static void main(String a[]){
        System.out.println(arr[0]);
    }

}

答案:不会,初始化的时候会赋初始值0,5个0

接口

接口中只能有静态的不能被修改的成员,也就是必须是static final的

如果是Java 7以及以前的版本,那么接口中可以包含的内容有:1. 常量;2. 抽象方法
如果是Java 8,还可以额外包含有:3. 默认方法;4. 静态方法
如果是Java 9,还可以额外包含有:5. 私有方法

4.
在JAVA中,假设A有构造方法A(int a),则在类A的其他构造方法中调用该构造方法和语句格式应该为()

A、this.A(x)
B、this(x)
C、super(x)
D、A(x)

解析:


答案:B
this的作用其中一个就是在一个构造方法中调用另一个构造方法,格式为this(参数); super是调用父类的方法 比如super.start();
A(a)这种形式是在new一个类时使用。

基类 导出类

基类就是父类,也叫超类。导出类就是子类,也叫派生类。

threadLocal

关于ThreadLocal类 以下说法正确的是
A.ThreadLocal继承自Thread
B.ThreadLocal实现了Runnable接口
C.ThreadLocal重要作用在于多线程间的数据共享
D.ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E.ThreadLocal保证各个线程间数据安全,每个线程的数据不会被另外线程访问和破坏

答案:de
1、ThreadLocal的类声明: public class ThreadLocal 可以看出ThreadLocal并没有继承自Thread,也没有实现Runnable接口。所以AB都不对。 2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。 所以ThreadLocal重要作用并不在于多线程间的数据共享,而是数据的独立,C选项错。 由于每个线程在访问该变量时,读取和修改的,都是自己独有的那一份变量拷贝,不会被其他线程访问, 变量被彻底封闭在每个访问的线程中。所以E对。 3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本: 所以D对。

servlet生命周期

Servlet生命周期分成3个阶段:
1)初始化阶段:调用init方法
2)响应客户请求:调用service
3)终止:调用destory方法

初始化阶段:在下列时刻servlet容器装载servlet

1 servlet容器启动时,自动装载某些servlet
2 在servlet容器启动后,客户首次向servlet发送请求
3 servlet类文件被更新之后,重新装载servlet

Servlet被装载之后,servlet容器创建一个servlet’对象并调用servlet的init方法,在servlet生命周期内,init方法只能被调用一次。servlet工作原理:客户端发起一个请求,servlet调用service方法时请求进行响应,service对请求的方式进行了匹配,选择调用dopost或者doget等这些方法,然后进入对应方法中调用逻辑层的方法,实现对客户的响应。

响应客户请求:对于用户到达servlet的请求,servlet容器会创建特定于该请求的servletrequest和servletresponse对象,然后调用servlet的service方法,service方法从servletrequest对象中获取客户请求的信息,处理该请求,并且通过servletresponse对象向客户端返回响应信息。

终止:当web应用终止或者servlet容器终止或servlet容器重新装载servlet新实例时,servlet容器会调用servlet对象的destory方法,在destory方法中可以释放servlet占用的资源

易错题

下面输出什么:

Boolean flag = false;
if (flag = true)
{
    System.out.println("true");
}
else
{
    System.out.println("false");
}

答案: true
看清,flag = true 不是

第二

下面哪段代码插入进来不会报错

interface Com{
    int M=200;
    int f();
}
class ImpCom implements Com{
    【代码】
}

>
A. public int f(){return 100+M;}
B. int f(){return 100;}
C. public double f(){return 2.6;}
D. public abstract int f();

答案:A
B选项没有修饰符,不知道是public default 还是什么
1、必须实现接口中所有的方法。
在实现类中实现接口时,方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致,并且必须实现接口中的所有方法。

2、接口实现类相当于子类,子类的访问权限是不能比父类小的。
接口中所有方法默认都是public,至于为什么要是public,原因在于如果不是public,那么只能在同个包下被实现,可访问权限就降低很多了,那么在实现类中,实现的类相当于子类,子类的访问权限是不能比父类小的,而在java中一个类如果没有权限的修饰符,默认是friendly(同一个包内的其它类才可访问),所以在实现类中一定要写public

类型转换

语句1,2,3,4哪几个是错的?

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

答案: 1,3,4

1、所有的byte,short,char型的值将被提升为int型;
2、如果有一个操作数是long型,计算结果是long型;
3、如果有一个操作数是float型,计算结果是float型;
4、如果有一个操作数是double型,计算结果是double型;
5、被fianl修饰的变量不会自动改变类型,当2个final修饰相操作时,结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误:b3=(b1+b2);自动转为int,所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int;
语句2正确:b6=b4+b5;b4、b5为final类型,不会自动提升,所以和的类型视左边变量类型而定,即b6可以是任意数值类型;
语句3错误:b8=(b1+b4);虽然b4不会自动提升,但b1仍会自动提升,所以结果需要强转,b8=(byte)(b1+b4);
语句4错误:b7=(b2+b5); 同上。同时注意b7是final修饰,即只可赋值一次,便不可再改变。

反射

getDeclaredField:查找该Class所有声明属性(静态/非静态),但是他不会去找实现的接口/父类的属性
getField:只查找该类public类型的属性,如果找不到则往上找他的接口、父类,依次往上,直到找到或者已经没有接口/父类

public Object getName1() throws NoSuchFieldException, IllegalAccessException {
        return User.class.getDeclaredField("name").get(null);
    }
    public Object getName2() throws NoSuchFieldException, IllegalAccessException {
        return User.class.getField("name").get(null);
    }
    public Object getName3() throws NoSuchFieldException, IllegalAccessException {
        User user=new User(); return user.getClass().getField("name").get(user);
    }
    public Object getName4() throws NoSuchFieldException, IllegalAccessException {
        User user=new User(); return user. getClass().getDeclaredField("name").get (user);
    }

get方法是获得user对象下前面指定好的属性的值,而获取static属性时get()括号里的对象可以写成null

多态

下面代码输出什么?

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

答案:两个150
多态绑定机制:
实例方法与引用变量所引用的对象的方法绑定;
静态方法与引用变量所声明的类型的方法绑定;
成员变量(实例变量、静态变量)与引用变量所声明的类型的成员变量绑定。
在这道题目中,由于都是实例方法,所以与所引用的对象的方法绑定。(new 后跟引用对象)

涉及转型的题目,分为向上或者向下转型。 关键的来了,不论向上或者向下转型,都是一句话,“编译看左边,运行看右边”。也就是编译时候,会看左边引用类型是否能正确编译通过,运行的时候是调用右边的对象的方法。A a=new B();这是向上转型。B b=(B)a;这是向下转型。但是,A a =new A();B b= (B)a;此时会报错。 就本题来说,编译时候会发现左边满足条件所以编译通过,运行时候又会调用右边也就是 class B 的方法,所以答案都是150。

下面关于变量及其范围的陈述哪些是不正确的()
A。实例变量是类的成员变量
B。实例变量用关键字static声明
C。在方法中定义的局部变量在该方法被执行时创建
D。局部变量在使用前必须被初始化

答案:BC
解析:
类的成员变量包括实例变量和类变量(静态变量),成员方法包括实例方法和类方法(静态方法)
C.方法中的局部变量在方法被调用加载时开始入栈时创建,方法入栈创建栈帧包括局部变量表操作数栈,局部变量表存放局部变量,并非在执行该方法时被创建,C错误
D.局部变量被使用前必须初始化,否则程序报错。D正确

finally

下面输出什么

public class Demo {
    public static String sRet = "";
    public static void func(int i)
    {
        try
        {
            if (i%2==0)
            {
                throw new Exception();
            }
        }
        catch (Exception e)
        {
            sRet += "0";
            return;
        } 
        finally
        {
            sRet += "1";
        }
        sRet += "2";
    }
    public static void main(String[] args)
    {
        func(1);
        func(2);
        System.out.println(sRet);
    }
}

答案:1201
解答:
第一步,func(1),if条件不成立,不抛出异常,catch不运行,final运行,拼串得到“1”,程序继续往下走,拼串得到“12”。 第二步,fun(2),if条件成立,抛出异常,catch捕获异常,运行catch里面代码,拼串得到“120”,虽然有return,但是不管出不出异常,final里代码必须执行,执行final,拼串得到“1201”,然后return结束。所以最终结果“1201”

下列流当中,属于处理流的是:()     
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream
按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。

节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.
处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。
JAVA常用的节点流:

文 件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
字符串 StringReader StringWriter 对字符串进行处理的节点流。
数 组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流(对应的不再是文件,而是内存中的一个数组)。
管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。


常用处理流(关闭处理流使用关闭里面的节点流)

缓冲流:BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter  增加缓冲功能,避免频繁读写硬盘。
转换流:InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream  等-提供将基础数据类型写入到文件中,或者读取出来.
流的关闭顺序
一般情况下是:先打开的后关闭,后打开的先关闭
另一种情况:看依赖关系,如果流a依赖流b,应该先关闭流a,再关闭流b。例如,处理流a依赖节点流b,应该先关闭处理流a,再关闭节点流b
可以只关闭处理流,不用关闭节点流。处理流关闭的时候,会调用其处理的节点流的关闭方法。

servlet体系结构

分类: java

0 条评论

发表评论

Avatar placeholder

您的电子邮箱地址不会被公开。 必填项已用*标注

ICP备案号: 辽ICP备20003309号