JAVA SE 基础学习笔记(一)

本笔记为初学Java基础时的笔记,年代久远,可参考性不大。
本笔记为初学Java基础时的笔记,年代久远,可参考性不大。
本笔记为初学Java基础时的笔记,年代久远,可参考性不大。
本笔记为初学Java基础时的笔记,年代久远,可参考性不大。
本笔记为初学Java基础时的笔记,年代久远,可参考性不大。

1.(循环,数据类型,数组简介)

1.循环

1 for (int i = 0; i < num; i++) {
2 // 代码
3 }
4 while (condition) {
5 // 代码
6 }
7 do {
8 // 代码
9 } while (condition);
10 //针对数组、集合的遍历循环
11 for(int k : arr) {
12 System.out.println(arr[k])
13 }
14
15 break; //跳出循环,循环终止
16 continue;//跳出本次循环,循环继续
17 return //返回(一个对象,可为空)(代码执行到此,停止执行后续代码。作用域为当前对象内)

2.数据类型

1 //字符型
2 //字符型变量只能有一个字符,且只能使用单引号。
3 char a = '1';
4
5 // 字符串
6 String a1 = "aaa1";
7 String a2 = new String("aaa2");
8 String a3 = a1 + a2;
9
10 int len = a1.length();
11 // 取字符串长度
12 String str1 = a1.substring(1);
13 // 从指定下标开始截取,直到末尾。取右边
14 String str1 = a1.substring(1, 3);
15 // 从开始下标截取,到结束下标。取指定位置,不包括结束下标
16 int i1 = a1.indexOf("a");
17 // 获取指定字符的下标
18 char char1 = a1.charAt(2);
19 // 获取指定下标位置的字符
20 Boolean b1 = a1.equals(a2);
21 // 比较a1与a2的字符串的值是否相等
22 Boolean b2 = a1.contains("abc");
23 // 判断a1是否包括指定字符。

3.数组

1 //定义数组:
2 //数组类型[] 数组名 = new 数组类型[数组长度]
3 //数组长度表示数组中可以储存元素的个数
4 int[] arr = new int[6]
5 //给数组赋值
6 arr[1] = 2;
7 arr[2] = 3;
8 //数组长度
9 int len = arr.length;
10 //遍历数组
11 for(int k : arr) {
12 System.out.println(arr[k])
13 } //特定写法,使用数组、集合
14 for (int i = 0; i < args.length; i++) {
15 // 代码
16 } //普通写法,通过args.length确定
17

2.(Set,List,Map集合简介)

1.Set集合:元素无序,不可重复。

1 //1.1创建set集合
2 Set<String> set = new HashSet<>();
3 //<E> 泛型,表示该合集中的数据类型
4
5 //1.2添加数据
6 set.add("aaa");
7 set.add("bbb");
8 set.add("aaa");
9 set.add("ccc");
10 System.out.println(set);
11 // 结果 :[aaa, ccc, bbb] 当其中元素改变,集合中元素顺序也会改变。
12
13 //1.3遍历合集
14 //这种遍历方式要注意String k 处的String,该数据类型要同数组/集合中的元素数据类型保持一致。
15 for (String k : set) {
16 System.out.println(k);
17 }
18
19 //1.4获取集合长度,即元素个数
20 int len = set.size();
21

2.List集合:元素有序,可重复。

1 //2.1创建list集合
2 List<String> list = new ArrayList<>();
3
4 //2.2添加数据
5 list.add("aaa");
6 list.add("bbb");
7 list.add("aaa");
8 list.add("ccc");
9 System.out.println(list);
10 //结果:[aaa, bbb, aaa, ccc]
11
12 //2.3遍历合集
13 for (String k : list) {
14 System.out.println(k);
15 }
16
17 //2.4获取指定下标位置的值
18 String v = list.get(3);
19 System.out.println(v);
20 //结果:aaa
21
22 //2.5获取集合长度,即元素个数
23 int len = list.size();

3.Map集合:储存键/值对,键唯一且不可重复

1 //3.1创建map集合
2 Map<String, String> map = new HashMap<>();
3
4 //3.2添加元素
5 map.put("k1", "张三");
6 map.put("k2", "李三");
7 map.put("k1", "王五");
8 System.out.println(map);
9 //结果:{k1=王五, k2=李三},键(key)是唯一的,不可重复的
10
11 //3.3获取指定键的值
12 String v = map.get("k1");
13
14 //3.4获取map集合的长度,即键/值对个数
15 int len = map.size();
16
17 //3.5获取集合中的所有键
18 Set<String> keySet = map.keySet();
19 for(String k : keySet) {
20 System.out.println(map.get(k));
21 }
22 //.keySet() :返回一个由map中所有的key组成一个set集合。
23 //上述可以写成
24 for(String k : map.keySet()) {
25 System.out.println(map.get(k));
26 }
27
28

3.(类,对象概念简介)

1.类,对象

1
2 public class demo2 {
3
4 String name;
5 int age;
6
7 public void speak() {
8 System.out.println("speak");
9 }
10
11
12 public void run() {
13 System.out.println("run");
14 }
15
16 public static void main(String[]args) {
17 /*
18 * 类 只是对一类事物的特征和行为的定义
19 * 对象 是根据类的定义,创建的实际存在的个体
20 * 通过new 关键字完成类的实例化(创建类的对象)
21 * 通过new 关键字给对象分配内存空间
22 */
23

3.1 JDK JAVA开发工具包,提供java编程开发,编译(javac),执行的相关支持。

3.2 JRE java运行环境,提供java程序运行的支持(jar包的支持)

3.3jvm java虚拟机 ,运行编译之后的字节码文件

类 :类型,是一个模板,是对事物特征和行为的描述;具有相同属性和相同行为的事物,

才能被归为一类。

对象:对象是类的一个实体(实例)。

变量:类对象的特征。

方法:类对象的行为。

举例:

人【类】,是对一群生物群体的称呼,他们都有相同的【特征】和【行为】

生活在人类群体中的一个个人,就是人【类】的实际存在的【对象】

人有身高体重,就是【对象】的特征【变量】

人能吃饭跑步,就是【对象】的行为【方法】

24 demo2 d2 = new demo2();
25
26 d2.speak();
27 d2.name = "张三";
28 }
29 }

4.(JAVA运行基础知识)

1.java代码运行过程

2.安装jdk,配置系统变量

3. JDK相关概念解释

4.类、变量、方法

1 //声明一个类
2 public class Demo{

5.1 区分大小写

5.2 类名首字母大写,遵循驼峰命名法

5.3变量名、方法(函数)名首字母小写

5.4源文件名必须和类名相同,后缀是.java 编译后的文件后缀是.class

5.5 主方法入口,所有的java程序入口都在

3 //变量 对象的特征/属性
4 String name;
5 int age;
6
7
8 //方法 对象的行为/方法
public void speak(){ //该声明方式为局部方法,public static void a()为声明全局方
法
9
10 }
11
12 //调用方法
13 Demo test = new Demo();
14 test.speak();
15
16
17 }

5.基本语法规范

1 public static void main(String[] args) {}

6.手动编译

5.(数据类型,运算符)

1.基本数据类型

默认值为 0 ,数字的默认类型为int。

byte 1字节 short 2字节 int 4字节 long 8字节

float 4字节 double 8字节
boolean 1字节
char 占 2 字节

根据精度由低到高排序:

1.1 整数类型

1 byte 8bit,short 16bit, int 32bit ,long 64bit

1.2 浮点型(小数)

1 float 32bit ,double 64bit

1.3 布尔型

1 boolean true or false

1.4 字符型

1 char 16bit

1.5 精度排序

1 byte -> short,char -> int -> long -> float -> double

根据上面的顺序,低精度数据类型的变量,可以自动转为高精度类型的变量

高精度向低精度转换,会发生数据丢失或者溢出。

3.1 byte a = 1 ;byte b = a+ 1 ;

该写法错误, 1 的默认数据类型为int a的数据类型为byte,精度不同,无法相加。

3.2 short a = 1; a += 1;

正确,+=左右两边类型不同时会自动强制转换,+号不会。

3.

byte a = 10;byte b = 15;

byte c = a+b;//编译错误,a+b会自动转成int类型。

byte、short、char的数据在进行算术计算时,JVM会自动将其转成int类型再进行计算,

所以最终结果是int类型的

2.类型转换

2.1自动类型转换:低-->高

1 byte a1 = 12;
2 int a2 = a1 ;

2.2强制类型转换:高--->低

1 int a = (int) (Math.random() * 100);

3.常见笔试题

4.运算符

4.1 算术运算符:+, -, *, / ,%(取余)

自增:++ 自减:--

短路运算:如果根据条件 1 的结果已经可以得出逻辑运算的结果,那么后续条件语句就不会

继续执行。

例如:条件1 && 条件 2 ,如果条件1 = false ,条件 2 语句就不会执行。同理适用于 ||

例如:

1 )二进制数从右向左计算

2 )每一位的值乘以 2 的(二进制位数-1)次方

3 )所有结果相加,即为 10 进制数

例如:

1 i++与++i的区别:
2 i++ ,i变量先参与运算,再自增 +1,
3 ++i ,i变量先自增+1,再参与运算。

4.2 逻辑运算符: &&,|| , != ( 且 或 非)

4.3 比较运算符:<, > , == ,<= , >=

4.4 赋值运算符:=, += ,-= ,*= ,/=, %=

1 a += 1 : a = a + 1
2 a %= 2 : a = a % 2

4.5位运算符:

4.5.1 十进制转二进制

4.5.2 二进制转十进制

1) 在计算机世界中,所有的数据都是以补码的形式存在于计算机中的.

2) 正数: 原码 = 反码=补码

3 )负数:

反码 = 原码按位取反(取反,不包括符号位)

补码 = 反码 + 1

例如:

0101 原码

1010 反码

1011 补码

1 ) "& " 按位与

2 ).其他不再详细解释

~非运算符,二进制的补码按位取反,一般正数的非运算符 = - (正数+1)

三元运算符两边的类型不一致时,会自动将低精度转为高精度。
1 1010 转十进制
2 0*2^0 = 0
3 1*2^1 = 2
4 0*2^2 = 0
5 1*2^3 = 8
6 即 1010 转十进制为 10
7

4.5.3 原码 反码 补码

4.5.4 按位运算符

1 int a = 2; //
2 int b = 3; //
3 //结果0 0 1 0 再转为十进制就是 2
4 a & b 结果为 2

5.三元运算符 选择表达式

tips:不确定的就()起来。

1 a = 条件? 2 : 3
2 //等同于
3 if (条件) {
4 a = 2;
5 } else {
6 a = 3;
7 }
8 条件true 就赋值 2 ,条件false 赋值 3
9 条件 ? 值 if true :值 if false
10

6.运算符优先级

6.(分支,循环,数组,排序)

1.知识回顾

1.1 JAVA 的基本数据类型有哪几个?

1 byte , short , int , long , char , float , double , boolean

1.2 基本数据类型中,按照精度从小到大的排序是?

1 byte -> short,char -> int -> long -> float -> double

1.3 java中数字的默认数据类型是?

1 int

1.4 a++ 与 ++a的区别是?

1 a++ ,a变量先参与运算,再自增 +1,
2 ++a ,a变量先自增+1,再参与运算。

1.5 &&与&的区别是?

1 && 逻辑与,运算符两边比较的是布尔值,两边都为true,结果为true,否则false
& 按位与,运算符两边比较的是数字类型,两边数字的二进制按位比较,如果对应位都是 1 ,结果为 1 ,否则
为 0 。
2

1.6 短路运算规则?

1 短路运算:如果根据条件 1 的结果已经可以得出逻辑运算的结果,那么后续条件语句就不会继续执行。
2 例如:条件1 && 条件 2 ,如果条件1 = false ,条件 2 语句就不会执行。同理适用于 ||

2.分支结构

2.1 if语句

1 if (condition1) {
2
3 } else if (condition2) {
4
5 } else if (condition3) {
6
7 } else { ///不属于 123 的其他情况
8
9 }

2.2 switch语句

1 switch (key) {
2 case value1:
break; //如果不加break,该语句会继续往下执行,且不论下一个条件是否成立,后续代码都会
执行。
3
4 case value2:
break; //如果不加break,该语句会继续往下执行,且不论下一个条件是否成立,后续代码都会
执行。
5
6 default:
7 break;
8 }

3.循环结构

3.1 whlie循环

1 while (condition) {
2
3 }

3.2 do whlie循环

1 do {
2
3 } while (condition);

3.3 for循环

1 for (int i = 0; i < args.length; i++) { //普通
2
3 }
4
5 for(String k : arr){ //for each,遍历数组或集合
6
7 }

3.4 嵌套循环

1 fa: for (int i = 0; i < args.length; i++) {
son: for (int i = 0; i < args.length; i++) { ///可以给循环指定别名,通过break 别名;跳
出指定循环
2
3
4 }
5 }
6
7 break; //跳出循环,循环终止
8 continue;//跳出本次循环后,循环继续
9 return //返回(一个对象,可为空)(代码执行到此,停止执行后续代码。作用域为当前对象内)

4.数组

1 //定义数组:
2 //数组类型[] 数组名 = new 数组类型[数组长度]
3 //数组长度表示数组中可以储存元素的个数
4 int[] arr = new int[6]
5 int[] arr = {1,2,3,4,5,6,7}
6 //给数组赋值
7 arr[1] = 2;
8 arr[2] = 3;
9 //数组长度
10 int len = arr.length;
11 //遍历数组
12 for(int k : arr) {
13 System.out.println(arr[k])
14 } //特定写法,使用数组、集合
15 for (int i = 0; i < args.length; i++) {
16 // 代码
17 } //普通写法,通过args.length确定
18

5.排序

5.1冒泡排序

1 public class demo2 {
2 public static void main(String[] args) {
3 int[] arr = { 1, 8, 75, 42, 42, 8 };
4 for (int i = 0; i < arr.length; i++) {
5
6 for (int j = 0; j < arr.length - 1; j++) {
7
8 if (arr[j] > arr[j + 1]) {
9 int tar = arr[j];
10 arr[j] = arr[j + 1];
11 arr[j + 1] = tar;
12 }
13 }
14 }
15 System.out.println( Arrays.toString(arr));
16 }
17 }

7.(String及所属方法)

1.字符串及所属方法

1.1 s1.equals(s2) 比较两个字符串的值是否相等,返回一个布尔值

1 System.out.println("abc".equals(s2));

1.2 s1 instanceof String 判断一个变量是否是后面的数据类型,返回一个布尔

1 System.out.println(s2 instanceof String);

1.3 .length() 返回字符串长度

1 System.out.println(s2.length());

1.4 .trim() 去掉字符串两端的空格,返回结果

1 String s4 = " a aa ";
2 System.out.println(s4.trim());
3 结果:a aa //中间的不会去掉

1.5 .replace(oldChar,newChar) 替换字符串,返回替换后的新字符串

1 System.out.println(s2.replace("abc", "ABC"));

1.6 s1.concat(s2) 拼接s1.s2字符串

1 System.out.println(s1.concat(s2));

1.7 大小写转换

1 .toUpperCase() 转大写
2 System.out.println(s2.toUpperCase());
3 .toLowerCase() 转小写
4 System.out.println(s1.toLowerCase());

1.8 .split(char) 根据指定字符切分字符串,返回一个结果的字符串数组

1 String s8 = "a1:a2:a3";
2 String[] arr = s8.split(":");
3 System.out.println(Arrays.toString(arr));
4 //结果:[a1, a2, a3]

1.9 .contains() 判断字符串是否包含指定字符

1 String s9 = "abc";
2 System.out.println(s9.contains("a"));
3 //结果 true
4 System.out.println(s9.contains("ac"));
5 //结果 false 查找的字符必须是目标字符串的一部分

1.10 .substring(stratNunber,overNunber) 截取开始下标到结束下标的字符

串,结束下标可省略,省略则截取到末尾

1 String s10 = "asdwad54545454844";
2 System.out.println(s10.substring(5)); //下标是从 0 开始
3 // 结果: d
4 System.out.println(s10.substring(5,10)); //不包括结束下标 [5,10)
5 // 结果: d

1.11 .indexOf(char) 获取指定字符在字符串中第一次出现的下

标,.lastindexOf()

1 String s11 = "wbcaaaaa";
2 System.out.println(s11.indexOf("a"));
3 // 结果: 3

1.12 .charAt(num) 获取指定下标位置的字符

1 String s12 = "a123"
2 System.out.println(s12.charAt(0);

1.13 .isEmpty() 判断字符串是否为空串,返回布尔型

1 String s131 = "";
2 String s132 = null;
3 String s133 = "abc";
4 System.out.println(s131.isEmpty()); //true
5 System.out.println(s132.isEmpty()); //报错
6 System.out.println(s133.isEmpty()); //false

1.14 .toCharArray() 字符串转字符数组,返回数组

1 String s14 = "asd156a1w5d1651";
2 char[] arr = s14.toCharArray();
3 System.out.println(Arrays.toString(arr));
4 //结果:[a, s, d, 1, 5, 6, a, 1, w, 5, d, 1, 6, 5, 1]

1.15 String.valueOf(char) 其他类型转字符型,返回字符型

1 )== : 比较 基本数据类型 时,比较的是 值 是否相等
2 )== : 比较 引用类型 时,比较的是 内存地址 是否相等
ps:除了 8 种数据类型,其余的类都是引用类型。
3 ) Object类 的equals()比较的是 内存地址 是否相同
4 ) String类 的equals()比较的是 值 是否相同
1 //double a = 2.15691521527D;
2 int a = 15151656;
3 // boolean a = true //布尔值不参与任何类型转换?
4 String b = String.valueOf(a);
5 System.out.println(b);
6 System.out.println(b instanceof String);

8.(相等性规则,StringBuffer)

1.相等性规则: == , equals()

1 String s1 = "aaa";
2 String s2 = new String("aaa");
3 String s3 = "aaa";
4 String s4 = "a" + "aa";
5 String s5 = "a" + new String("aa");
6
7
8 System.out.println(s1 == s2); //false
9 //String为引用类型,只有 8 种基础数据类型(byte,short,int,long,boolean,char,float,double)
//引用类型比较的是内存地址,s1内存地址为常量池中的地址,s2指向的是堆中复制品的地址,所以
false
10
11 System.out.println(s1 == s3); //true
12 //s1与s3的赋值方式在内存中运行逻辑相同,均指向常量池中同一个常量的内存地址,所以相同。true
13 System.out.println(s1 == s4); //true
14 //s4式子的最终结果还是先拼接运算,然后再赋值给s4,所以跟s1是一样的。
都是一种String类型,可以多次修改,并且内存地址不变。
与String不同的是,该类型每次改变,都是将改变之后的新值覆盖旧值。
StringBuffer是线程安全的,Stringbuilder是不安全的

new时,要在堆中新开一块内存,存储stringbuffer相关的值和方法。在通过 方法 对 值 的

改变过程中,始终都是在一个固定的内存中操作,所以不会改变内存地址。

15 System.out.println(s1 == s5); //false
16 //s5的最终结果一定是在堆中的内存地址。
17

2.StringBuffer和StringBuilder

2.1 定义

关于stringbuffer运行过程的解释:

2.2 常用方法

1 StringBuffer sf = new StringBuffer("aaa");
2 StringBuffer sf = new StringBuffer("aaa"); //定义一个StringBuffer

2.2.1 .append(String) 拼接字符串,

1 sf.append("bbb");
2 System.out.println(sf.hashCode());
为什么拼接后sf的内存地址不变?
new StringBuffer时,在堆中分配了一个内存地址,之后对StringBuffer的操作都不会改变其内存地
址。
3 //拼接后的哈希值相同。

2.2.2 .reverse() 反转字符串

1 sf.reverse();

2.2.3 .delete(startIndex, endIndex) 删除字符串中指定下标范围的字符

1 sf.delete(3, 6); //删除 3 ,4,5下标的值,取不到 6
2

2.2.4 .insert(index, String). 在指定下标位置插入字符

1 sf.insert(1, "asdasd");

2.2.5 .replace(startIndex, endIndex, String). 替换指定索引区间内的字符串

1 sf.replace(1, 2, "1515asdf");

2.2.6 .length(). 获取字符串长度

即:最多可以存储的字符个数。
默认容量长度 : 16
初始容量长度= 传入参数的字符长度+16
例如,StringBuffer sf = new StringBuffer("aaa"); 的容量长度就是 16+3=19
拼接时,不改变容量长度,如果持续拼接到超过长度,新的长度等于原长度<<1 + 2 ,即原长度*2 + 2
1 ) 栈stack:后进先出,后来者居上 , 主要用来存储基本数据类型。
2 ) 堆heap:堆中用来存储引用类型的值。
3 )基本数据类型的存储方式为 : int a = 123 ,即变量名和值都存储在栈中
4 )引用数据类型的存储方式为 : String a = 内存地址,内存地址指向堆中的一处内存地址。
1 )StringBuffer所属方法的底层运行逻辑为:
直接改变原有StringBuffer的值,再返回StringBuffer
2 )String 所属方法的底层运行逻辑为:
复制一份原有的String,对复制的String进行操作,返回操作之后的复制String,并不会改变原有的
String值。
1 )String a = "abc"的内存中逻辑:
先去堆中的字符串常量池中查找是不是存在abc,如果有,则string a = 该常量的内存地址
如果没有,则在常量池中创建常量,然后再string a = 该常量的内存地址
2 )String a = new String("abc")的内存中逻辑:
1 sf.length();

2.2.7 .capacity(); 获取容量长度

1 sf.capacity();

3. 内存基础知识:栈和堆

4. String与StringBuffer在方法方面的区别?

5. String a = "a"; String b = new String("a");的区别?

先去堆中的字符串常量池中查找有没有abc,如果有,则将该常量复制一份到堆中,如果没有,则先复
再复制一份到堆中,该方法最终指向的地址是堆中的地址。

成员变量:系统会根据该变量的类型赋予其相应的特征值,不手动赋值,也不会报错。

局部变量:声明之后系统不会赋予默认值,必须自己手动赋值,否则会报错。

即可修饰变量,又可修饰方法。一共有四种访问权限修饰符:
1 )private 本类

9.(变量,修饰符,方法)

1.成员变量和局部变量

1.1 成员变量:独立于方法外的变量,直接在主类中声明的变量。

1.2 局部变量:在方法中定义的变量称为局部变量,局部变量只在其所属的方法中

起作用。

1.3.两者区别:

1 package demo2;
2
3 public class hello1 {
4 //成员变量 在类中的变量
5 String name;
6 int age;
7 public void speak() {
8 //局部变量 在普通方法里的变量
9 String s1 = "aaa";
10 //s1只存在于speak方法中,只有先调用speak才能使用s1
11 }
12
13 }

2.修饰符

2.1 访问权限修饰符

2 )默认的 无修饰符 本类、同包
3) protected 受保护的 本类、同包、不同包的子类
4). public 公共的 本类、同包、不同包子类、不同包的其他类
ps:限定了变量的作用域

1 )void 无返回值

2 )String 返回字符 int返回数值 boolean 返回布尔值

3 )声明方法时如果给定了返回值类型,则方法中必须带有指定类型的返回值。

每个类都有构造方法,如果不写,系统会自动添加无参构造方法。
构造方法的主要功能是完成对象的初始化。
若有返回值类型,最后需要return相应类型的值;
若返回值类型为void(无返回值),则可以不写return;
成员方法名和类名不能相同。
在一个类中,存在方法名相同,参数列表不同的方法,方法会发生重载。
1 )重载发生同一个类中
2 )重载的方法名相同
3 )重载的参数列表不同(个数,顺序,数据类型)
4 ) 返回值类型是否发生改变不作为重载的判断依据。

2.2 返回值修饰符

3 构造方法和成员方法

3.1构造方法:一种特殊的方法,方法名和类名相同,没有返回值(没有return)

3.2成员方法:一个类中除了构造方法之外的方法。

4 重载

4.1定义

4.2特点

1 public class Demo1 {
2 String name;
3 int age;
4
5 public Demo1() { //无参构造方法
6 }
7 public Demo1(String name ,int age) { //有参构造方法 该写法为初始化对象写法
8 this.name = name;
9 this.age = age;
10 }
11 //以上,两个构造方法,参数名相同,参数列表不同,发生重载。
12 public String speak() { //成员方法
13 return "aaa";
14 }
15 public int con(int a,int b) { //成员方法
16 int c = a*a*a*a+b
17 return c;
18 }
19 }
20
21

10.(封装,继承,this)

1.知识回顾

1.1.重载的特点是什么?

1 1)重载发生同一个类中
2 2)重载的方法名相同
3 3)重载的参数列表不同(个数,顺序,数据类型)
4 4)返回值类型是否发生改变不作为重载的判断依据

1.2.构造方法的特点?

1 1)方法名必须与类名一致
2 2)没有返回值关键字
3 3)用于完成创建对象后的初始化操作

1.3.相等性原则?

1 1)== 比较基本数据类型,比较值
2 2)== 比较引用数据类型,比较内存地址
3 3)Object类的equals()比较的是内存地址
4 4)String类的equals()比较的是值

1.4.a++于++a的区别?

1 1 )a++是a先参与代码的运行,再自增,
2 2 )++a是先自增,再参与代码运行。

1.5.&& 和 & 的区别?

1 1 )&&,逻辑与,比较的是布尔值,只有所有条件的结果都为true时,返回true,否则返回false
2 2 )&,按位与,比较的是二进制数,二进制数按位比较,都为 1 ,返回 1 ,否则返回0.

1.6.String /StringBuffer/StringBuilder的区别?

1 1 )StringBuffer是线程安全的,Stringbuilder是不安全的
2 2 )StringBuffer和Stringbuilder的值可以多次修改,且内存地址不变.
3 3 )StringBuffer的所属方法为直接改变原有StringBuffer的值,再返回改变后的StringBuffer。
2 )String所属方法为先复制一份原有的String,对复制的String进行操作,返回操作之后的复制String,
并不会改变原有的String值。
4

1.7.String a = "a"; String b = new String("a");的区别?

1 1 )String a = 123;先去常量池查找 123 ,没有就创建,然后存储该位置的内存地址
2 )String b = new String(123);先去常量池查找 123 ,没有就创建,然后复制到堆内存中,再存储堆中
的内存地址
2

1.8.冒泡排序

1 //要求可以手写出来
2
3 int[] arr = { 1, 8, 75, 42, 42, 8 };
4 for (int i = 0; i < arr.length; i++) {
5
6 for (int j = 0; j < arr.length - 1; j++) {
7
8 if (arr[j] > arr[j + 1]) {
9 int tar = arr[j];
10 arr[j] = arr[j + 1];
11 arr[j + 1] = tar;
12 }
13 }
14 }
15 System.out.println(Arrays.toString(arr));
16

1.9.短路运算

1 短路运算:如果根据条件 1 的结果已经可以得出逻辑运算的结果,那么后续条件语句就不会继续执行。
2 例如:条件1 && 条件 2 ,如果条件1 = false ,条件 2 语句就不会执行。同理适用于 ||

10.break与continue的区别?

代码示例见继承。

1 )所有类都有父类,所有类都继承Object类

2 )只能单亲继承,每一个子类只能有一个父类

3 )子类只能继承父类的非private修饰的变量和方法

即,子类不能继承父类的私有属性,但是可以通过父类的public方法去使用父类的私有属

4 )子类可以直接使用继承的变量和方法,不需要再声明。

5 ) 子类如果有无参构造方法,则父类必须有一个无参构造方法。

PS:son s1 = new Son(); 此处的Son()表示son里的构造方法。

6 )创建子类对象的加载顺序:1.加载父类构造对象 2.子类构造方法-成员方法

1 break; //跳出循环,循环终止
2 continue;//跳出本次循环,循环继续
3 return //返回(一个对象,可为空)(代码执行到此,停止执行后续代码。作用域为当前对象内)

2.面对对象三要素

2.1 封装 :成员变量私有化,提供公有的set和get方法

2.2 继承:子类可以不需要声明,直接调用父类的资源(成员变量与方法)

2.2.1继承的特点

1 //本代码与封装处代码类比:
2 package demo2;
3 public class hello1 {
4
5 private String name; ///成员变量私有化
6 String sex;
7 //快速生成set和get方法:
8 //类文件空白位置,点击鼠标右键——source——Generate Getters and Setters
9 public String getName() { //提供公有的set和get方法
10 return name;
11 }
12 public void setName(String name) { //提供公有的set和get方法
1 )通过this关键字可以明确地去访问一个类的成员变量, 解决与局部变量名称冲突的问题。
2 )通过this关键字,调用成员方法;
3 )构造方法是实例化对象时被java虚拟机自动调用的,在程序中不能像调用其他方法一样去调用构造
方法, 但是可以通过
this(参数一,参数二,,,)这种方式在一个构造方法中去调用另一个构造方法。
1 )只能在构造方法中使用this调用其他构造方法,不能在成员方法中使用this调用构造方法。
2 )在构造方法,使用this关键字调用构造方法的语句必须放在第一行。且只能出现一次。
3 )两个构造方法,不能通过this关键字去互相调用。
4 )this指代的是当前类实例化之后的对象。
5 )this不能在静态资源中使用。
13 this.name = name;
14 }
15 }
16 ///*************************************************************//
17 package demo2;
18
19 public class hello3 extends hello1{
20 public static void main(String[] args) {
21 hello3 s1 = new hello3();
s1.name = "asdasd"; //报错,name是父类的私有属性,没有继承,所以无法直接更
改。
22
s1.sex = "aaa"; //不报错,sex是父类的非private属性,可以继承,可以更
改。
23
s1.setName("张三"); //不报错,setAge是公开的成员方法,子类可以使
用。
24
25 }
26 }

3 this关键字

3.1定义:表示当前类的对象。

3.2用法:

3.3注意事项:

暂无评论

发送评论 编辑评论


				
上一篇
下一篇