java语言基础(面试相关)

1.java语言有哪些特点?

  1. 面向对象
  2. 平台无关性,一次编译,到处运行
  3. java提供很多的内置类库
  4. java提过了对web应用开发的支持
  5. 具有较好的安全性和健壮性
  6. 比c++语言更简洁,严谨

2.什么是java的字节序?

java字节序指的是在java虚拟机中多字节类型数据的存放顺序,java字节序是Big-Endian(大端)。

3.java中的final关键字?

  1. final关键字可以用于成员变量、本地变量、方法以及类。
  2. final成员变量必须在声明的时候初始化或者在构造器中初始化,否则就会报编译错误。
  3. 你不能够对final变量再次赋值。
  4. 本地变量必须在声明时赋值。
  5. 在匿名类中所有变量都必须是final变量。
  6. final方法不能被重写。
  7. final类不能被继承。
  8. final关键字不同于finally关键字,后者用于异常处理。
  9. final关键字容易与finalize()方法搞混,后者是在Object类中定义的方法,是在垃圾回收之前被JVM调用的方法。
  10. 接口中声明的所有变量本身是final的。
  11. final和abstract这两个关键字是反相关的,final类就不可能是abstract的。
  12. final方法在编译阶段绑定,称为静态绑定(static binding)。
  13. 没有在声明时初始化final变量的称为空白final变量(blank final
    variable),它们必须在构造器中初始化,或者调用this()初始化。不这么做的话,编译器会报错
  14. “final变量(变量名)需要进行初始化”。
  15. 将类、方法、变量声明为final能够提高性能,这样JVM就有机会进行估计,然后优化。
  16. 按照Java代码惯例,final变量就是常量,而且通常常量名要大写

finally:


接口可以多实现,继承只能单继承


形参和实参的区别?

形参:

全称为“形式参数”,是定义方法名和方法发体的时候调用的参数,木的是用来接收该方法时传递的参数,它的作用范围是整个方法体,实在方法调用时的一个临时变量,实参出先在主调方法中,在方法调用的时候把是惨的值赋给对应的形参,在被调用的方法的内部只能使用形参,不能使用形参。

实参和形参的区别:

  1. 形参的作用范围为方法内部,当方法调用结束后,形参的生命周期也就结束了,因此,在方法外不能使用形参。它只有在被调用是才分配内存单元,调用结束后会立即释放内存空间,而实参不能在调用方法的内部使用。
  2. 在方法调用的时候,只能把实参的值传递给形参,而不能把形参的值反向的传递给实参,因此,在方法的调用过程中,对形参的值的改变不会影响实参的值。

&和&&的区别?

1.&是按位与操作符,a&b是把a和b都转换成二进制数后,然后再进行按位与的运算。而&&是逻辑与的运算符,a&&b就是当二个数的值都为true时结果才为true,否则结果为false;
2.此外&&还有短路的作用,在参与运算的二个表达式中,只有当第一个表达式的结果为true时,才会继续计算第二个表达式的值。

可变参数

示例:

String… a,其中string是可变参数的类型,a是其名称
特点:
1. 只能作为最后一个参数出现,
2. 只能位于变量的类型和变量名之间。String… a;
3. 编译器为可变参数隐式的创建了一个数组,在调用的时候可以通过数组的形式来访问可变参数

获取Class(字节码对象)对象的三种方法

  1. 通过调用对象的.getClass()方法
  2. 通过Class.forName(“包名.类名”)来获取
  3. 通过 类名.class语法来获取。

访问修饰符

在java语言中,类的权限访问修饰符有以下几种:private default protected public。

  1. private:private可以修饰数据成员、构造方法和方法成员,不可以修饰类,被private修饰的成员,只能在定义他们的类中使用,在其他类中不能被调用。(只能在本类中使用)
  2. 默认权限(default):类、数据成员、构造方法和方法成员等都能够使用默认权限。默认权限即同包权限,同包权限的元素只能在定义他们的类中以及同包的类中被调用(本类和同包类)。
  3. 受保护权限(protected):可以修饰数据成员构造方法和方法成员,不可以修饰类,被protected修饰的类只能在定义它的类和子类中被访问(本类和子类)。
  4. 公共权限(public):public可以修饰类、数据成员、构造方法和方法成员。被public修饰的成员可以在任何一个类中被调用,不管同包或不同包。是权限最大的修饰符(本包和不同包)。
  5. 访问修饰符的权限由大到小依次是:public protected default和private。

面向对象的三大特性?

  1. 继承
  2. 封装
  3. 多态

this和super?

关键字this指的是当前对象的引用 关键字
super指的是当前对象里面的父类的应用
通果super可以调用父类的构造方法,父类的方法和属性

实例方法和类方法?

  1. 实例方法:没有用static修饰,也叫非静态方法
  2. 类方法:用static修饰,也叫静态方法

详解:

实例方法:
当类的字节码文件加载到内存中时,类的实例方法并没有被分配入口地址,只有当该类的对象创建以后,实例方法才分配了入口地址。从而实例方法可以被类创建的所有对象调用,还有一点需要注意,当我们创建第一个类的对象时,实例方法的入口地址会完成分配,当后续在创建对象时,不会再分配新的入口地址,也可以说,该类的所有对象共享实例方法的入口地址,当该类的所有对象被销毁,入口地址才会消失。
类方法:
当类的字节码文件加载到内存,类方法的入口地址就会分配完成,所以类方法不仅可以被该类的对象调用,也可以直接通过类名完成调用。类方法的入口地址只有程序退出时消失。

遵循的规则:

1.在类方法中不能引用实例变量
实例变量的定义类似实例方法,没有用static修饰的变量,实例变量的创建与实例方法的创建相同,也是在类的对象创建时完成,所以在类方法中是不能引用实例变量的,因为这个时候实例变量还没有分配内存地址。

2.在类方法中不能使用super和this关键字
这是因为super和this都指向的是父类和本类的对象,而在类方法中调用的时候,这些指代的对象有可能都还没有创建。
3. 类方法中不能调用实例方法

注意:

  1. 实例方法可以引用类变量和实例变量

  2. 实例方法可以使用super和this关键字

  3. 实例方法中可以调用类方法

String StringBuffer 和StringBuilder的区别?

1.可变和不可变
String类中提供了数值不可改变的字符串。
StringBuffer和StringBuilder的字符串是可以被改变的
2.有没有重写equals和hashcode方法
String重写了equals和hashcode方法

3 三者的执行速度:

StringBuilder>StringBuffer>String

原因:

String是字符串常量
StringBuilder和StringBuffer是字符串变量

从上面的名字可以看到,String是“字符创常量”,也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问 ,比如这段代码:

1 String s = "abcd";
2 s = s+1;
3 System.out.print(s);// result : abcd1

    我们明明就是改变了String型的变量s的,为什么说是没有改变呢? 其实这是一种欺骗,JVM是这样解析这段代码的:首先创建对象s,赋予一个abcd,然后再创建一个新的对象s用来执行第二行代码,也就是说我们之前对象s并没有变化,所以我们说String类型是不可改变的对象了,由于这种机制,每当用String操作字符串时,实际上是在不断的创建新的对象,而原来的对象就会变为垃圾被GC回收掉,可想而知这样执行效率会有多底。
    而StringBuffer与StringBuilder就不一样了,他们是字符串变量,是可改变的对象,每当我们用它们对字符串做操作时,实际上是在一个对象上操作的,这样就不会像String一样创建一些而外的对象进行操作了,当然速度就快了。
3.一个特殊的例子:

1 String str = “This is only a” + “ simple” + “test”;
2 StringBuffer builder = new StringBuilder(“This 
is only a”).append(“ simple”).append(“ test”);

    你会很惊讶的发现,生成str对象的速度简直太快了,而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏,实际上:


String str = “This is only a” + “ simple” +“test”;

    其实就是:
   

 String str = “This is only a simple test”;

    所以不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的String对象的话,速度就没那么快了,譬如:  

       String str2 = “This is only a”;

    String str3 = “ simple”;

    String str4 = “ test”;

    String str1 = str2 +str3 + str4;

    这时候JVM会规规矩矩的按照原来的方式去做。

4.StringBuilder与 StringBuffer

StringBuilder:线程非安全的
StringBuffer:线程安全的

    当我们在字符串缓冲去被多个线程使用是,JVM不能保证StringBuilder的操作是安全的,虽然他的速度最快,但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作,所以大多数情况下是建议用StringBuilder而不用StringBuffer的,就是速度的原因。

对于三者使用的总结

1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

重载和重写的区别?

重载:

指同一个类中的多个方法具有相同的名字,但是这些方法具有不同的参数列表,级参数的数量和类型不能完全相同,返回值类型可以相容也可以不相同。

规则:

  1. 必须具有不同的参数列表
  2. 可以有不同的返回类型,也可以相同
  3. 可以有不同的访问修饰符
  4. 可以抛出不同的异常

重写:

父类与子类之间的多态性,对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写。

规则:

  1. 参数列表必须完全与父类的相同
  2. 返回的类型必须和父类的方法的返回值相同
  3. 访问修饰符的限制一定要大于父类的修饰符
  4. 抛出的异常不能大于父类的

重载和重写的区别?重载的方法能否根据返回类型进行区分?

方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的参数列表,有兼容的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求,不能根据返回类型进行区分。

转发和重定向的区别?

Throw和Throws的区别?

用户程序自定义的异常和应用程序特定的异常,必须借助Throws和Throw语句来抛出异常。
当需要显示的抛出一个异常(通常情况下是用户自定义的异常)时,需要使用关键字Throw来抛出异常,而关键字throws用来列出一个方法可能会抛出的异常类型。
示例:

class MyException extends Exception{}
public class Test{
//告诉方法的调用者这个方法可能会抛出MyException异常
public void f(int i) throws MyException{
if(i==1)
当满足条件的时候抛出自定义的异常
throw new MyException();
    }
}

二者其他的不同:

  1. Throws通常出现在函数头,而Throw通常出现在函数体
  2. Throws表示出现异常的一种可能,并不一定会发生这些异常;而Throw则是抛出了异常,即如果执行throw,则一定抛出了某种异常
  3. 二者都是消极处理异常的方式(这种消极并不是说着种方式不好),只是抛出或者可能抛出异常,但是不会有函数取处理异常,真正的处理异常有函数的上层调用处理。

java中final、finally和finalize的区别是什么?

  1. final用于声明属性、方法和类,分别表示属性不可变、方法不能被重写、类不能被继承
    final修饰属性:被final修饰的变量不可变,由于不可变有二种含义:一是引用不可变,二是对象不可变,final指的到底是什么呢?
    举例说明:
public class  Test{
    public static void main(String[] args) {
        final StringBuffer s=new StringBuffer("hello");
        s.append("world");
        System.out.println(s);
    }
}

运行结果为:
hello world
public class  Test{
    public static void main(String[] args) {
        final StringBuffer s=new StringBuffer("hello");
       s=new StringBuffer("hello world");
    }
}

编译期间错误

从以上的例子可以看出,final指的是引用的不可变性,即她只能指向初始时指向的对象,而不关心指向的对象的内容,所以,被final修饰的变量必须被初始化。
初始化的几种方式:


  1. 在定义的时候初始化
  2. final成员变量可以在初始化块中进行初始化,但不可以在静态初始化块中进行初始化

3.在类的构造器中初始化,但静态final成员变量不可以在构造方法中初始化

final方法:的当一个方法被声明final时,该方法不允许任何子类重写该方法,但子类仍然可以使用这个方法,
final参数:用来表示这个参数在方法的内部不允许被修改
fianl类:当一个类被生命为final时,此类不能被继承,所有的方法都不能被重写,但这并不是说final类的成员变量也是不可改变的,要想做到final类的成员变量也是不可改变的,必须给成员变量增加final修饰。
注意:一个类不能即被修饰为abstract又被修饰为final。

Tomact优化经验

  1. 去掉对web.xml的监视,把jsp提前编辑成Servlet
  2. 在有富余物理内存的情况下,加大tomact使用的jvm的内存
  3. 利用缓存和压缩
  4. 采用集群

Http请求的get方式和post方式的区别?

  1. get的参数通过url传递,而post参数通过request body传递
  2. get请求在url中传递的参数的长度是有限制,而post没有
  3. get比post更不安全,因为get是直接暴露在url中的
  4. get请求只能进行url编码,而post可以进行多种编码
  5. get请求会让浏览器主动cache,而post不会
  6. get请求参数会被完整保留在浏览历史记录里,而post中的参数不会被保留。
  7. GET产生一个TCP数据包;POST产生两个TCP数据包。

forward和redirect的区别

forward是服务器请求资源,服务器直接访问目标地址的url,把那个url的响应内容读取过来,然后把这些内容再发给浏览器,浏览器根本不知道服务器发送的内容来自哪里,所以它的地址栏还是原来的地址。
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新取请求那个地址,一般来说浏览器会用刚才请求的参数重新请求,所以,session和request参数都可以获取。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值