0:方法不能独立存在
Java里的方法不能独立存在,它必须属于一个类或一个对象,因此方法也不能像函数那样被独立执行,执行方法时必须使用类或对象来作为调用者,即所有方法都必须使用"类.方法"或"对象.方法"的形式来调用。
public class A {
public String B(){
return "This is a test";
}
public String C(){
return this.B();
}
public String D(){
return B();
}
}
注意:同一个类的一个方法调用另外一个方法时,如果被调用方法是普通方法,则默认使用 this 作为调用者;如果被调用方法是静态方法,则默认使用类作为调用者。也就是说,表面上看起来某些方法可以被独立执行,但实际上还是使用 this 或者类来作为调用者;
1:以下代码输出为?
public class B
{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println("构造块");
}
static
{
System.out.println("静态块");
}
public static void main(String[] args)
{
B t = new B();
}
}
//输出构造块 构造块 静态块 构造块
静态块:用static申明,JVM加载类时执行,仅执行一次;
构造块:类中直接用{}定义,每一次创建对象时执行;
执行顺序优先级:静态块>构造块>构造方法;
并不是静态块最先初始化,而是静态域,而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.而他们两个的初始化顺序是靠他们俩的位置决定的!
类的加载顺序:
- 父类静态代码块(包括静态初始化块,静态属性,但不包括静态方法)
- 子类静态代码块(包括静态初始化块,静态属性,但不包括静态方法 )
- 父类非静态代码块( 包括非静态初始化块,非静态属性 )
- 父类构造函数
- 子类非静态代码块 ( 包括非静态初始化块,非静态属性 )
- 子类构造函数
2:以下代码输出为?
Boolean flag = false;
if (flag = true)
{
System.out.println(“true”);
}
else
{
System.out.println(“false”);
}
//输出true
java赋值语句的返回值等于要赋的值
3:
public class B
{
public class C{}
private class D{}
protected class E{}
class F{}
}
对于外部类来说,只有两种修饰,public和默认(default),因为外部类放在包中,只有两种可能,包可见和包不可见;
对于内部类来说,可以有所有的修饰,因为内部类放在外部类中,与成员变量的地位一致,所以有四种可能;
4:
口诀:淡云一笔安洛三福 单目>算数运算符>移位>比较>按位>逻辑>三目>赋值
5:重写的规则
重写必须遵循两同两小一大 规则:
- 方法名相同,参数类型相同
- 返回值类型小于等于父类的返回值类型
- 抛出异常小于等于父类抛出异常,也就是抛出的异常更加精确
- 访问权限大于等于父类
重载的规则:同名不同参,返回值无关
6:
class A{
private String name = "Person";
int age=0;
}
public class B extends A{
public String grade;
public static void main(String[] args){
A p = new B();
System.out.println(p.name); //报错 The field A.name is not visible
}
}
一个Java文件里,public 的类只能出现一个;子类无法访问父类的私有成员;
子类继承父类的所有成员,包括private权限的成员变量,但是继承的子类只具有私有变量的拥有权但是没有使用权;
7:以下代码输出为?
public class A {
int a = 5;
public static void main(String[] args) {
System.out.println(a); //报错
}
}
静态方法内不能调用非静态成员;
8:
J2SDK(Standar Development Kit for Java 2) 简称JDK;
9:标识符
标识符由字母(大小写英文字母)、数字(0~9)、下划线(_)和$符号组成,不能由数字打头;也可以是Unicode字符集中的字符,如汉字;
public class A {
static String 中文 = "asds";
public static void main(String[] args) {
System.out.println(中文); //输出asds
}
}
10:
package test;
import java.util.Date;
public class SuperTest extends Date{
private static final long serialVersionUID = 1L;
private void test(){
System.out.println(super.getClass().getName());
}
public static void main(String[]args){
new SuperTest().test(); //输出test.SuperTest
}
}
- 首先 super.getClass() 是父类的getClass()方法,其父类是Date,它的getClass()方法是继承自Object类而且没有重写, 所以就是调用object的getClass()方法。而看一下getClass的方法解释如下图
所以可以知道是返回当前运行时的类; 所以可以知道是返回当前运行时的类;与Date类无关,要返回Date类的名字需要写super.getClass().getSuperclass(); - 在调用getName()方法而getName()返回的是:包名+类名;
11:以下代码中输出为
class Base{
public Base(String s){
System.out.print("B");
}
}
public class Derived extends Base{
public Derived (String s) {
System.out.print("D");
}
public static void main(String[] args){
new Derived("C"); //编译错误
}
}
子类构造方法在调用时必须先调用父类的,由于父类没有无参构造,必须在子类中显式调用,修改子类构造方法如下即可:
public Derived(String s){
super("s");
System.out.print("D");
}
12:变量a、b、c分别在内存_____存储区存放
class A {
private String a = "aa";
public boolean methodB() {
String b = "bb";
final String c = "cc";
}
}
变量a、b、c分别在内存的堆区、栈区、栈区存储区存放;
a是类中的成员变量,存放在堆区;b、c都是方法中的局部变量,存放在栈区;
13:A派生出子类B,B派生出子类C,在Java源代码中有如下声明。是否正确?
A a0=new A();
A a1 =new B();
A a2=new C();
都是正确的;
继承具有传递性,子类可以无条件向上转型!
14:所有的异常类皆直接继承于?
所有的异常类皆直接继承于java.lang.Exception;
15:Java中基本的编程单元为?
java的基本编程单元是类,基本存储单元是变量。
16:以下语句错误的是?
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;
------------知识点------------
Java表达式转型规则由低到高转换:
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修饰,即只可赋值一次,便不可再改变。
17:Java语言中,如果"xyz"没有被创建过,String s =new String(“xyz”);创建了几个string object?
两个。第一个在堆中,第二个在字符串常量池中!如果在Java字符串常量池中已经存在,就只会创建一个;
18:Java 程序中使用赋值运算符进行对象赋值时,可以得到两个完全相同的对象?
错误。对象赋值时,比如A=B,只是把A对象的地址指向了B对象的地址,所以其实对象只有一个;
19:以下代码的输出是
class Foo {
final int i;
int j;
public void doSomething() {
System.out.println(++j + i);
}
}
不能执行,因为编译有错;
final类型的变量一定要初始化,因为final的变量不可更改。
20:下面代码运行结果是
public class Test{
public int add(int a,int b){
try {
return a+b;
}
catch (Exception e) {
System.out.println("catch语句块");
}
finally{
System.out.println("finally语句块");
}
return 0;
}
public static void main(String argv[]){
Test test =new Test();
System.out.println("和是:"+test.add(9, 34));
}
}
输出: finally语句块 和是:43
- 不管有木有出现异常,finally块中代码都会执行;
- 当try和catch中有return时,finally仍然会执行;
- finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,不管finally中的代码怎么样,返回的值都不会改变,仍然是之前保存的值),所以函数返回值是在finally执行前确定的;
- finally中最好不要包含return,否则程序会提前退出,返回值不是try或catch中保存的返回值。
举例:
- 情况1 :try{} catch(){}finally{} return;
显然程序按顺序执行。 - 情况2 :try{ return; }catch(){} finally{} return;
程序执行try块中return之前(包括return语句中的表达式运算)代码;
再执行finally块,最后执行try中return;
finally块之后的语句return,因为程序在try中已经return所以不再执行。 - 情况3 :try{ } catch(){return;} finally{} return;
程序先执行try,如果遇到异常执行catch块,
有异常:则执行catch中return之前(包括return语句中的表达式运算)代码,再执行finally语句中全部代码,
最后执行catch块中return. finally之后也就是4处的代码不再执行。
无异常:执行完try再finally再return. - 情况4 :try{ return; }catch(){} finally{return;}
程序执行try块中return之前(包括return语句中的表达式运算)代码;
再执行finally块,因为finally块中有return所以提前退出。 - 情况5 :try{} catch(){return;}finally{return;}
程序执行catch块中return之前(包括return语句中的表达式运算)代码;
再执行finally块,因为finally块中有return所以提前退出。 - 情况6 :try{ return;}catch(){return;} finally{return;}
程序执行try块中return之前(包括return语句中的表达式运算)代码;
有异常:执行catch块中return之前(包括return语句中的表达式运算)代码;
则再执行finally块,因为finally块中有return所以提前退出。
无异常:则再执行finally块,因为finally块中有return所以提前退出。
最终结论 :任何执行try 或者catch中的return语句之前,都会先执行finally语句,如果finally存在的话。
如果finally中有return语句,那么程序就return了,所以finally中的return是一定会被return的,
编译器把finally中的return实现为一个warning。
21:下列不属于java语言鲁棒性(健壮性)特点的是
A java能检查程序在编译和运行时的错误
B java能运行虚拟机实现跨平台
C java自己操纵内存减少了内存出错的可能性
D java还实现了真数组,避免了覆盖数据的可能
答案:B
跨平台不属于鲁棒性
22:下面不是面向对象的基本原则的是?
A 单一职责原则(Single-Resposibility Principle)
B 开放封闭原则(Open-Closed principle)
C 抽象类原则(Abstract-Class principle)
D 依赖倒置原则(Dependecy-Inversion Principle)
E 接口隔离原则(Interface-Segregation Principle)
答案:C
面向对象的五大基本原则
单一职责原则(SRP)
开放封闭原则(OCP)
里氏替换原则(LSP)
依赖倒置原则(DIP)
接口隔离原则(ISP)
23:构造函数不能被继承,只能被调用
24:Java中使用 final 关键字定义常量
25:Java关键字都是小写
26:Path环境变量
编译和运行 Java 程序必须经过两个步骤:
- 将源文件编译成字节码;
- 解释执行平台无关的字节码程序;
这两个步骤分别需要使用 javac 和 java 两个命令。
计算机如何查找命令呢?Windows 操作系统根据 Path 环境变量来查找命令。Path 环境变量的值是一系列路径,Windows 操作系统在这一系列的路径中依次查找命令,如果能找到这个命令,则该命令是可执行的;否则将出现 “xxx不是内部或外部命令,也不是可运行的程序或批处理文件” 的提示。
而 Linux 操作系统则根据 PATH 环境变量来查找命令,PATH 环境变量的值也是一系列路径。因为 Windows 操作系统不区分大小写,设置 Path 和 PATH 并没有区别;而 Linux 系统是区分大小写的,设置 Path 和 PATH 是有区别的,因此只需要设置 PATH 环境变量即可;
27:CLASSPATH环境变量
1.5以上版本的 JDK,完全可以不用设置 CLASSPATH 环境变量------即使不设置 CLASSPATH 环境变量,完全可以正常编译和运行 Java 程序;
那么 CLASSPATH 环境变量的作用是什么呢?
如果使用 1.4 以前版本的 JDK,则需要在 CLASSPATH 环境变量中添加一点(.),用以告诉 JRE 需要在当前路径下搜索 Java 类;
除此之外,编译和运行 Java 程序还需要 JDK 的 lib 路径下 dt.jar 和 tools.jar 文件中的 Java 类,因此还需要把这两个文件添加到 CLASSPATH 环境变量里;
因此,如果使用1.4 以前版本的 JDK 来编译和运行 Java 程序,常常需要设置 CLASSPATH 环境变量的值为:
//%JAVA_HOME%代表 JDK 安装目录,设置 JAVA_HOME 的原因就是不用每次都修改
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
后来的 JRE 会自动搜索当前路径下的类文件,而且使用 Java 的编译和运行工具时,系统可以自动加载 dt.jar 和 tools.jar 文件中的 Java 类,因此不再需要设置 CLASSPATH 环境变量;
28:形参个数可变的方法
JDK 1.5 之后,Java 允许定义形参个数可变的参数,从而允许为方法指定数量不确定的形参。如果在定义方法时,在最后一个形参的类型后增加三点(…),则表明该形参可以接受多个参数值,多个参数值被当成数组传入:
public class TestVarargs {
public static void test(int a,String...books)
{
for(String tmp : books)
{
System.out.println(tmp);
}
System.out.println(a);
}
public static void main(String[] args) {
test(5,"疯狂 Java 讲义","轻量级 Java EE 企业应用实战");
}
}
形参个数可变的参数本质就是一个数组参数:
public static void test(int a,String[] books)
这两种形式都包含了一个名为 books 的形参,在两个方法的方法体内都可以把 books 当成数组处理。但区别是调用两个方法时存在差别:
test(5,"疯狂 Java 讲义","轻量级 Java EE 企业应用实战");
test(23,new String[]{"疯狂 Java 讲义","轻量级 Java EE 企业应用实战"});
第一种更加简洁;
注意:个数可变的形参只能处于形参列表的最后。一个方法中最多只能包含一个个数可变的形参。
29:String、StringBuffer、StringBulider
String类是不可变类,即一旦一个 String 对象被创建以后,包含在这个对象中的字符序列是不可改变的,直至这个对象被销毁;
StringBuffer 对象则代表一个字符序列可变的字符串,当一个 StringBuffer 被创建以后,通过 StringBuffer 提供的 append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过 StringBuffer 生成了最终想要的字符串,就可以调用它的 toString() 方法将其转换为一个 String 对象;
JDK1.5 又新增了一个 StringBulider 类。StringBulider 与 StringBuffer 基本相似。不同的是,StringBuffer 是线程安全的,而 StringBulider 则没有实现线程安全功能,所以性能略高。因此在通常情况下,如果需要创建一个内容可变的字符串对象,则应该优先考虑使用 StringBulider 类;
速度:StringBulider > StringBuffer > String
30:DDL、DML
DDL(数据定义语言,Data Definition Language) ----------- 创建(create)、删除(drop)和修改(alter)数据库对象,最基本的数据库对象是数据表,数据表是存储数据的逻辑单元;
DML (数据操纵语言,Data Manipulation Language ) ----------- 插入新数据(insert into)、修改已有数据(update)、删除数据(delete from);
31:查询(select)语句
查询中用到的关键词主要包含六个,并且他们的顺序依次为 : select–from–where–group by–having–order by
group by:分组
having:对已经分组的数据进行过滤的条件
order by:排序
当一个查询语句同时出现了where,group by,having,order by的时候,执行顺序是:
- 执行where xx对全表数据做筛选,返回第1个结果集。
- 针对第1个结果集使用group by分组,返回第2个结果集。
- 针对第2个结果集中的每1组数据执行select xx,有几组就执行几次,返回第3个结果集。
- 针对第3个结集执行having xx进行筛选,返回第4个结果集。
- 针对第4个结果集排序。
32:JDBC编程步骤
- 加载驱动:Class.forName();
- 通过 DriverManager 获取数据库连接:DriverManager.getConnection(String url,String user,String pass);
- 通过 Connection 对象创建 Statement 对象;
- 使用 Statement 执行 SQL 语句;
- 操纵结果集;
33:MySQL语句
1:create
create table student
(
name char(10),
sex char(2),
age int
);
2:alert
//增加一个 address 字段,类型为 varchar;
alter table student
add address varchar(255);
//增加 aaa、bbb 字段,两个字段的类型都为 varchar(255);
alter table student
add
(
aaa varchar(255),
bbb varchar(255)
);
//删除 student 表中的 aaa 字段
alter table student
drop aaa;
//将 student 表重命名为 test
alter table student
rename to test;
//将 student 表的 bbb字段重命名为 ccc 并更改类型为 int;
alter table student
change bbb ccc int;
3:drop
//删除数据表 student
drop table student
4:update
//将数据库表 student 中的 name 字段的值都改为 '杨东'
update student
set name = '杨东';
//将数据库表 student 中年龄大于20的 name 字段的值改为 '杨东'
update student
set name = '杨东' where age > 20;
5:delete from
//删除数据库表 student 中的所有记录
delete from student;
//删除数据库表 student 中年龄大于20的记录
delete from student
where age > 20;
34:constructor必须与class同名,但方法不能与class同名?
错误,方法能与class同名;
public class Test {
public void Tets(){
System.out.println("-----");
}
public Test() {
}
public static void main(String[] args) {
Test test = new Test();
test.Tets();
}
}
//输出-----
35:用户不能调用构造方法,只能通过new关键字自动调用?
错误
- 在类的其他构造方法中可以用this()的方式调用其他构造方法;
- 在类的子类中则可以通过super调用父类中指定的构造方法;
- 在反射中可以使用newInstance()的方式调用。
36:try块后必须有catch块?
错误,try块后面不一定需要跟着catch块,可以只跟着finally块;
37:Java中的关键字有哪些?
1)48个关键字:abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
2)2个保留字(现在没用以后可能用到作为关键字):goto、const。
3)3个特殊直接量:true、false、null。
38:哪个语句是创建数组的正确语句?
除了f3都是对的,也就是说数组命名时名称与[]可以随意排列,但声明的二维数组中第一个中括号中必须要有值,它代表的是在该二维数组中有多少个一维数组
39:jre判断程序是否执行结束的标准是?
所有的前台线程执行完毕!
后台线程就是守护线程(比如垃圾回收,内存分配等),前台线程就是用户线程!