Java认证OCJP-1ZO-808复习材料总结

1.知识点a++,++a
a++是先使用后再自加,++a是先自加而后再使用;
例:

int a = 9;
System.out.println(a++);//输出9
System.out.println("中间过度值1:"+ a); //输出10
System.out.println(++a);//输出11
System.out.println("中间过度值2:"+ a); //输出11
System.out.println(a--);//输出11
System.out.println("中间过度值3:"+ a); //输出10
System.out.println(--a);//输出9

2.装箱和拆箱
装箱就是自动将基本数据类型转换为包装器类型;拆箱就是自动将包装器类型转换为基本数据类型;
3.构造函数
1.当我们定义类后不声明任何构造函数,则java虚拟机会帮我们创建一个空参构造。
2.当我们声明了一个有参构造,java虚拟机就不会帮我们创建一个空参构造,此时我们想用空参构造创建一个对象,那么就必须在类中声明一个空参构造。
比如1:

class Person{
	String name;
	int age;
}
定义一个Person类,没有声明构造函数,此时虚拟机会自动创建一个。
实际上:
class Person{
	String name;
	int age;
	//默认创建构造函数
	Person(){}
}

比如2:

class Person{
	String name;
	int age;
	//有参构造函数
	Person(String name,int age){
	this.name = name;
	this.age = age;
	}
	//此时java虚拟机不会创建无参构造函数,如要使用,则必须手动创建
	//无参构造函数
	Person(){}
}

4.构造函数中的super和this的使用
super用于调用父类构造函数的部分,其必须出现在构造函数的第一行。super在调用时第一件事就是去执行父类构造函数的部分,所执行的父类构造函数与super()括号中的参数相对应。
this用于在一个构造函数中调用同一个类另一个构造函数,其也必须是第一行语句。
super和this不能同时出现在一个构造函数中,其两个在使用时必须出现在构造函数的第一行语句,其区别为super调用父类构造函数,this调用自身类的构造函数。
为便于理解,可以将this理解为自己,也就是这个类本身,因此调用this是调用自己类的构造函数。
在这里插入图片描述
5.包路径
Java中引入包文件可以具体文件名,或者采用通配符的方式
声明两个基础类,一个在包sales下,另一个在包 sales.products下

package sales;

public class SalesMan {

}
package sales.products;

public class Product {
	
}

1.最原始的引用方式

package market;

import sales.SalesMan;
import sales.products.Product;

public class USMarket {
	SalesMan sm;
	Product p;
}

2.采用通配符 *,但是路径必须要精确到上一级;
正确做法:

package market;

import sales.*;
import sales.products.*;

public class USMarket {
	SalesMan sm;
	Product p;
}

错误做法:

package market;

import sales.*;

public class USMarket {
	SalesMan sm;
	Product p;//报错
}

6.while 和 do while 的区别
说明:
while循环开始后,先判断条件是否满足,如果满足就执行循环体内的语句,执行完毕后再回来判断条件是否满足,如此无限重复;直到条件不满足时,执行while循环后边的语句。简单来讲就是说while循环是先判断后循环, 判断如果满足条件进入循环 本次循环后再次判断 。

int a = 5;
while(a<10) {
	System.out.print(a);//输出结果:56789
	a++;
}

do-while循环与while循环的不同在于:它先执行循环中的语句,然后再判断表达式是否为真, 如果为真则继续循环;如果为假, 则终止循环。因此, do-while循环至少要执行一次循环语句。 简单来讲就是说while循环是先循环后判断 。

int a = 5;
do{
	System.out.print(a);//输出:5
	a++;
}
while(a==10); //当不满足条件时,终止循环

总结:
1.while先判断后执行,do while先执行后判断
2.当不满足循环条件时,while循环一次都不会执行,do while循环至少执行一次

7.switch case

switch(key){
    case value1 :
       //操作语句
       break; //可选
    case value2 :
       //操作语句
       break; //可选
    ....
    default : //可选,当不满足所有case时,默认执行
       //语句
}

其中key支持类型包括:
基本数据类型:byte, short, char, int
包装数据类型:Byte, Short, Character, Integer
枚举类型:Enum
字符串类型:String

case:
1.case 数量可以有无穷个;

break:
1.case 里面必须跟 break,不然程序会一个个 case 执行下去,直到最后一个 break 的 case 或者 default 出现;

default:
1.default语句可有可无,最多只能有一个;
2.default只有在case匹配失败的时候才会执行;
当然有种特殊情况,比如case 里面缺少了break,也会执行default

int key = 2;
switch(key){
    case 1 :
       System.out.print("1");
       break;
    case 2 :
       System.out.print("2");
    default : 
    System.out.print("default");
}
//输出:2 default

3.default的位置对执行结果有没有影响,关键看default有没有使用break;

int key = 3;
switch(key){
	default : 
    System.out.println("default");
    case 1 :
       System.out.println("1");
    case 2 :
       System.out.println("2");
       break;
}
//输出
//default
//1
//2
int key = 3;
switch(key){
	default : 
    System.out.println("default");
    	breakcase 1 :
       System.out.println("1");
    case 2 :
       System.out.println("2");
       break;
}
//输出
//default

所以,当不加break的时会继续向下执行,直到break或return或switch结束为止。

8.String的trim()方法
用来删除字符串两端的空白字符并返回
String a = " Hello World “;
String b = a.trim();
b就变成"Hello World”
注意:trim方法并不影响原来的字符串本身,它返回的是一个新的字符串

String str = " ";
str.trim();//str本身值未变化
System.out.println(str.equals("")); //false
System.out.println(str.isEmpty()); //false
String a = str.trim();
System.out.println(a.equals("")); //true
System.out.println(a.isEmpty()); //true

9.==,equals(),equalsIgnoreCase() 的区别
1.== 比较的是变量(栈)内存中存放的对象的(堆)内存地址,用来判断两个对象的地址是否相同,即是否是指相同一个对象。比较的是真正意义上的指针操作。

(1)比较的是操作符两端的操作数是否是同一个对象。
(2)两边的操作数必须是同一类型的(可以是父子类之间)才能编译通过。
(3)比较的是地址,如果是具体的阿拉伯数字的比较,值相等则为true,如:
int a=10 与 long b=10L 与 double c=10.0都是相同的(为true),因为他们都指向地址为10的堆。

2.equals用来比较的是两个对象的内容是否相等,由于所有的类都是继承自java.lang.Object类的,所以适用于所有对象,如果没有对该方法进行覆盖的话,调用的仍然是Object类中的方法,而Object中的equals方法返回的却是==的判断。
String s=“abce"是一种非常特殊的形式,和new 有本质的区别。它是java中唯一不需要new 就可以产生对象的途径。以String s=“abce”;形式赋值在java中叫直接量,它是在常量池中而不是象new一样放在压缩堆中。这种形式的字符串,在JVM内部发生字符串拘留,即当声明这样的一个字符串后,JVM会在常量池中先查找有有没有一个值为"abcd"的对象,如果有,就会把它赋给当前引用.即原来那个引用和现在这个引用指点向了同一对象,如果没有,则在常量池中新创建一个"abcd”,下一次如果有String s1 = “abcd”;又会将s1指向"abcd"这个对象,即以这形式声明的字符串,只要值相等,任何多个引用都指向同一对象.
  而String s = new String(“abcd”);和其它任何对象一样.每调用一次就产生一个对象,只要它们调用。
  也可以这么理解: String str = “hello”; 先在内存中找是不是有"hello"这个对象,如果有,就让str指向那个"hello".如果内存里没有"hello",就创建一个新的对象保存"hello". String str=new String (“hello”) 就是不管内存里是不是已经有"hello"这个对象,都新建一个对象保存"hello"。

3.equalsIgnoreCase() 方法用于将字符串与指定的对象比较,不考虑大小写。

String a = "hello";
System.out.println(a.toUpperCase());//HELLO,全部转为大写
String b = new String("hello");
String c = new String("hello");
String d = new String("HELLO");
System.out.println(d.toLowerCase());//hello,全部转为小写

System.out.println(b==c);//false
System.out.println(b==a);//false
System.out.println(b==d);//false

System.out.println(b.equals(a));//true
System.out.println(b.equals(c));//true
System.out.println(b.equals(d));//false

System.out.println(b.equalsIgnoreCase(c));//true
System.out.println(b.equalsIgnoreCase(a));//true
System.out.println(b.equalsIgnoreCase(d));//true
		
System.out.println(a.toLowerCase().equalsIgnoreCase(d.toLowerCase()));//true
System.out.println(b.toLowerCase().equalsIgnoreCase(d.toLowerCase()));//true
System.out.println(b.toUpperCase().equalsIgnoreCase(d.toUpperCase()));//true
System.out.println(b.toUpperCase().equalsIgnoreCase(c.toUpperCase()));//true

10. int float double 赋值操作
int 整型
float 单精度浮点数
double 双精度浮点数
1.声明 float a=1.5; 会编译报错,因为1.5是双精度数,将双精度(double)赋值给浮点型(float)属于向下转型会造成精度损失,因此需要强制类型转换f正确的写法 float a = (float)1.3;或者float a = 1.3f;(f或F都可以不区分大小写)
2.赋值操作过程中,不能向下转型;

int intValue = 100; //整型
float floatValue = 100.00f; //单精度
double doubleValue = 123; //双精度
// int < float < double;

intValue = floatValue; //编译错误
floatValue = intValue;

doubleValue = floatValue;	
floatValue = doubleValue; //编译错误

doubleValue = intValue;
intValue = doubleValue; //编译错误

11. import static和import的区别
import static静态导入是JDK1.5中的新特性。一般我们导入一个类都用 import com…ClassName;
而静态导入是这样:import static com…ClassName.;
这里的多了个static,还有就是类名ClassName后面多了个 .
,意思是导入这个类里的静态方法。当然,也可以只导入某个静态方法,只要把 .* 换成静态方法名就行了。然后在这个类中,就可以直接用方法名调用静态方法,而不必用ClassName.方法名 的方式来调用。

这种方法的好处就是可以简化一些操作,例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…),在使用时直接print(…)就可以了。
普通用法:

public class StaticTest {
	public static void main(String[] args) {
		System.out.println("hello");
	}
}

静态导入:

import static java.lang.System.out;
public class StaticTest {
	public static void main(String[] args) {
		out.println("hello");
	}
}

注意:
1.你必须说import static, 不能说static import。
2.提防含糊不清的命名static成员。例如,如果你对Integer类和Long类执行了静态导入,引用MAX_VALUE将导致一个编译器错误,因为Integer和Long都有一个MAX_VALUE常量,并且Java不会知道你在引用哪个MAX_VALUE。
3.你可以在static对象引用、常量(记住,它们是static 或final)和static方法上进行静态导入。

12.java中String.indexOf()用法
1.查找指定字符或字符串在字符串中第一次出现地方的索引,未找到的情况返回 -1.
String.indexOf(String str)

String str1="012345";
String str2="23";
System.out.println(str1.indexOf(str2)); //输出2

重载方法有
String.indexOf(String str,int index)
从index的地方开始找,返回第一次出现的索引

String str1="012345012345";
String str2="23";
System.out.println(str1.indexOf(str2,5)); //输出8

13.数组的定义方式,包括一维数组和多维数组

一维数组:

动态方式:指定数组长度

int data[] = new int[3]; /*开辟了一个长度为3的数组*/
data[0] = 10; // 第一个元素
data[1] = 20; // 第二个元素
data[2] = 30; // 第三个元素

或者分步:

int data[] = null;
data = new int[3]; /*开辟了一个长度为3的数组*/
data[0] = 1; // 第一个元素
data[1] = 2; // 第二个元素
data[2] = 3; // 第三个元素

静态方式:指定数组的元素

int data[] = {10,20,30}; /*开辟了一个长度为3的数组*/

遍历方式:

int data[] = {10,20,30};
for(int m = 0;m < data.length; m++) {
	System.out.print(data[m]);
}
// 输出 10,20,30
二维或者以上数组:
1.二维数组长度为2,其中每个元素又是长度为3的的数组;
// data里面包含2个数组,其中每个数组里面有3个元素
int[][] data = new int[2][3];
// [[0, 0, 0], [0, 0, 0]]

2.二维数组长度为2,每个元素不确定;

int[][] data = new int[2][];int[][] data = new int[2][0];
data[0] = new int[2]; // 二维数组第一个元素的数组长度为2;
data[1] = new int[5]; // 二维数组第二个元素的数组长度为5;
// [[ 0,  0], [ 0,  0, 0, 0, 0]]
注意不能这样声明,不能在空维度之后指定数组维度:
int b[][] = new int [][2];

3.直接声明数组所有元素

// 二维数组第一个元素的数组长度为3;
// 二维数组第二个元素的数组长度为5;
int[][] data = {{1,2,3},{4,5,6,7,8}}
// [[ 0,  0], [ 0,  0, 0, 0, 0]]

遍历方式:

int a[][] = {{1,2,3},{4,5},{6,7,8}};
for(int m = 0;m < a.length; m++) {
	for(int n = 0;n < a[m].length; n++) {
		System.out.print(a[m][n]);
	}
}
// 输出 1,2,3,4,5,6,7,8

14.continue和break的区别
continue:不再执行循环体中continue语句之后的代码,直接进行下一次循环;

int[] array = {1,2,3,4,5};
for(int i:array) {
	if (i == 2) { // i=2时,不执行输出操作,直接下一次循环,即i=3
		continue;
	};
	System.out.print(i); // 输出 1345
}

break:直接跳出当前循环体(while、for、do while)或程序块(switch);

int[] array = {1,2,3,4,5};
for(int i:array) {
	if (i == 2) { // i=2时,直接跳出当前循环,即循环结束;
		break;
	};
	System.out.print(i); // 输出 1
}

15.
未完待续。。

参考博文:
https://www.cnblogs.com/haoyunfeng/p/9557830.html
https://www.cnblogs.com/do-hardworking/p/10464366.html
https://www.cnblogs.com/heiming/p/7416444.html
https://www.cnblogs.com/smart-hwt/p/8296303.html

©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页