1.final常量(常量命名全为大写):
如:final double PI = 3.14;
2.标识符命名规范:
驼峰原则(大小大写):类名、成员变量、方法名
3.数据类型:基本数据类型(值类型)、引用数据类型
基本数据类型:int(4)、byte(1)、long(8)、short(2)、float(4)、double(8)、char(2)、boolean(无字节)
4. 引用数据类型(4个字节):class类、 interface接口、array数组
5.java语言整型常量的四种表示形式:
十进制、八进制(以0开头)、十六进制(以0x或0X开头)、二进制(以 0b或0B开头)
5.1.浮点型:
(1)浮点型不精确,尽量不要把浮点型的变量用于比较。
(原因:浮点数存在舍入误差,数字不能精确表示。)如果要精确表示,可以用java的BigDecimal类型。
(2)浮点常量默认类型时double,要改成float可以在数值后面加F或f。
如:float pi = 3.14;(错) 原因:3.14为double型
float pi = 3.14F;把3.14double型转为float型。
- ASCLL码中三个特殊节点 :A:65 a:97 ‘0’:48
- String字符串不是基本数据类型,是类。
- Boolean类型:True 和 False
- 二元运算符的运算原则:
5.2.整数运算:
如果两个操作数有一个为long,则结果也为long;
没有long时,不论操作数是short还是byte,结果都为int型。
5.3浮点运算:
如果两个操作数有一个为double,则结果为double
只有两个操作数都是float,则结果才是float
取模运算:结果的符号与左边操作数的符号一样。
如:-7%3=-1; 7%-3=1;
注明:两个整数相除,直接保留结果的整数部分,不保留小数部分(原因:没有四舍五入的规则。)
如:10/3=3;
6.位运算符(进行二进制位的运算):
<<:左移运算符,左移1位相当于乘2
>>:右移运算符,右移1位相当于除2取商
如:5<<1 == 5*2 4<<3 == 4*2*2*2
5>>1 ==5/2 20>>3 ==20/2/2/2
7.优先级:逻辑与>逻辑或 即&&优先级大于||
8.条件句:if单分支结构、if-else双分支结构、if-else if-else多分支结构;
9.continue outer;(带标签的continue,帮助我们从内部循环跳到外部循环)
如:outer:for(int i;i <150;i++){
for(int j =2;j<1;j++){
if(i%j ==0){
continue outer;//符合某个条件则跳转到outer那里}}}
10.while(){}循环,while条件中只能用Boolean类型,不能用int类型
C语言中while(1)可以通过,因为将int类型转为Boolean类型
Java中while(1)不能通过,只能放boolean类型;
11.方法的调用:
普通方法:对象.方法名
静态方法:类名.方法名
12.方法重载:(与返回值类型无关)
1.名称相同 2.形参数量不同 3.形参类型不同 4.形参顺序不同(2、34满足一点即可)
12.java是面向对象编程,C语言是面向过程编程;
面向过程是执行者思维; 面向对象是设计者思维
13.成员变量的默认值:(两大类型:值类型(1、2、3、4)、引用类型(5)))
1.整数:0 2.浮点型:0.0 3.字符型:‘\u0000’
4.布尔型:False 5.所有引用类型:null
14..栈、堆:
栈:1.栈描述的是方法执行的内存模型,每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)
- JVM为每个线程创建一个栈,用于存放该线程执行方法的信息(实际参数、局部变量等)
- 栈属于线程私有,不能实现线程间的共享!
- 栈的存储特性是“先进后出,后进先出”
- 栈是有系统自动分配,速度快,栈是一个连续的内存空间!
堆:1.堆用于存储创建好的对象和数组(数组也是对象)
- JVM只有一个堆,被所有线程共享
- 堆是一个不连续的内存空间,分配灵活,速度慢!
- this的使用(super同理):1.调用无参的构造方法,this()必须位于第一行
- 调用带参的构造方法,this(参数,参数)也必须在第一行
注明:构造方法中不可以用构造方法名来调用构造方法,只能用this()来调用。super则不同,系统会默认在子类重写父类的方法中的第一条语句中写super();
如:TestThis(){System.out.println();},在另一个构造方法中调用要在方法的第一行写this();调用带参的构造方法就是this(参数,参数)
15.java中的内存机制:
1.栈(存放地址):局部变量、对象
2.堆(存放地址):成员变量、方法
16.static静态:
- static方法只能调用静态(即static)成员变量和方法,不能调用非静态 成员变量和方法;
- ***静态初始化块,用于类的初始化操作,初始化静态属性(即static初始化块中,可以为静态成员变量赋初值,但不能定义静态成员变量,也可以调用静态方法,当子类继承父类时,编译会直接运行static代码块。)。***
class TestStatic{
static int i;
static double b;
static{
i = 10;
b=20;
System.out.println("i+b的结果为:"+(i+b));
}
}
public class HelloWrold extends TestStatic {
public static void main (String[] args){
}
(类中定义了static静态初始化块后,static会被直接执行,不用main方法中调用,一定会执行。上面代码块结果为:i+b的结果为:30.0)
17.instanceof运算符:instanceof是二元运算符,左边是对象,右边是类,当左边的对象是右边类或子类所创建的对象时,返回true;否则返回False;
即:对象是子类或者父类或者父类的父类创建的对象,都返回true。
System.out.println(s instanceof Student);(如果s是类Student创建的对象或者是Student的子类创建的对象时,返回true)
18.继承:子类继承父类,可以继承父类的所有的成员变量和方法(除了构造方法),但不见得可以直接访问(如:父类的私有成员变量和方法不能访问)
19.方法重写:子类重写父类的方法(即将父类的方法给覆盖了),调用方法时会先调用子类的方法,用super关键字才能调用父类的方法。
注意:子类不继承父类的构造方法,所以子类不能重写父类的构造方法;
子类继承了父类,子类的构造方法中,不论是带参还是不带参的,构造方 法中的第一条语句系统都会默认写一句super(),来调用父类的无参构造方法;
20.final修饰:变量不能重新赋值,方法不能被重写,类不能被继承;
21.IDEA的一些快捷键:
1.类的结构视图(目录):alt+7
2.看类的源码(Object等系统类):control+鼠标左键
3.自动生成构造方法:get、set方法、equals等:alt+insert
4.查看错误:alt+enter
5.重写方法:control+o
22.equals的用法:equals默认是比较两个东西的的地址的,可以重写equals进行别的比较,操作:单机右键+generate+equals() and hashcode()
如:对一些形参的比较,可以重写equals方法对ID或name或pw等进行比较是否相同。
public static void main(String[] args) {
TestObject t1 = new TestObject(ID:1001,name:"zhangsan",pw:"123");
TestObject t2 = new TestObject(ID:1001,name:"zhangsan",pw:"123");
System.out.println(t1.toString());
System.out.println(t2.toString());
System.out.println(t1.equals(t2));
}
}
23.关于protected的两个细节(章节:java快速入门83):
- 若父类和子类在同一个包中,子类可访问父类的protected成员(用super),也可以访问父类对象的protected成员(即在子类中,可以用父类创建的对象来调用protected成员变量);
- 若子类和父类不在同一个包中,子类可访问父类的protected成员(用super),不能访问父类对象的protected成员(即在子类中,不能用父类创建的对象来调用protected成员变量)。
- 类名定义的变量和方法:
类名定义的变量和方法与普通的变量和方法没什么区别,类名定义的变量,类型为自定义类型,这个变量可以调用类型所在类的属性(成员变量)方法。类名定义的方法和普通方法差不多,但最后要返回null,即return null;
24./**/多行注释的注意事项:
- 不要嵌套注释,即不要/*....../*.......*/*/,最好一个个注释,如:/*....*//*....*/
- 最好一个方法或者一个类一个类的注释,最好不要整个程序一起注释。
25.java中main方法中不能声明方法,因为main方法本身就是方法,方法中不能嵌套。
26.String字符串
package TestJavaSE;
//String字符串最常见的三种创建方式;
//String字符串为不可变类型,即private final修饰的
//因为S2和S3的字符串相同,所以S2和S3的地址也相同,所以17行返回true
//S4与S2和S3的字符串相同,但地址不同,因为S4的创建是用数组,所以S4!=S2和S3
//equals比较的是字符串是否相等,因为S2与S4的字符串相等,所以返回true
public class StringTest {
public static void main(String[] args) {
String S0 = null;
String S1 = "";
String S2 = "java";
String S3 = "java";
String S4 = new String("java");
System.out.println(S1.length());
System.out.println(S2.length());
System.out.println(S3.length());
System.out.println(S2.equals(S3));
System.out.println(S2==S3);
System.out.println(S2==S4);
System.out.println(S2.equals(S4));
}
}
27.String类(常用方法)
public class StringTest1 {
public static void main(String[] args) {
String S1 = "core java";
String S2 = "Core java";
System.out.println(S1.charAt(3));//提取下标为3的字符;e
System.out.println(S2.length());//字符串长度;9
System.out.println(S1.equals(S2));//比较两个字符串是否相等;False
System.out.println(S1.equalsIgnoreCase(S2));//比较两个字符串(忽略大小写);true
System.out.println(S1.indexOf("java"));//索引字符串S1中java的位置,有则返回索引下标,没有则返回-1;5
System.out.println(S1.indexOf("apple"));//索引字符串S1中apple的位置,有则返回索引下标,没有则返回-1;-1
//返回的是全新的字符串
String s = S1.replace(' ','&');//将S1中的空格替换成&;s="core&java"
System.out.println("replace is :"+s);
}
}
package TestJavaSE;
public class StringTest2 {
public static void main(String[] args) {
String s = "";
String S1 = "How are you?";
System.out.println(S1.startsWith("How"));//是否以How开头;true
System.out.println(S1.endsWith("you"));//是否以you结尾;false
s = S1.substring(4);//提取子字符串,从下标为4的开始到字符串结束为止;are you?
System.out.println(s);
s = S1.substring(4,7);//提取子字符串,下标[4,7),不包括7
System.out.println(s);//are
s = S1.toLowerCase();//将S1字符串转为小写;
System.out.println(s);//how are you?
s = S1.toUpperCase();//将S1字符串转为大写;
System.out.println(s);//HOW ARE YOU?
String S2 = " How old are you!! ";
s = S2.trim();//去除字符串首位的空格。注意:中间的空格不能去除
System.out.println(s);//"How old are you!!"
System.out.println(S2);//因为String是不可变字符串,所以S2不会变。
}
}
28.内部类:
- 内部类的两个要点:
- 内部类提供了更好的封装,只能让外部类直接访问,不允许同一个包中的其他类直接访问。
- 内部类可以直接访问外部类的私有属性,内部类被当成其外部类的成员,但外部类不能访问内部类的内部属性。
- 注意:内部类只是一个编译时的概念,一旦编译成功,就会成为完全不同的两个类;如:Outer类中有个Inner内部类,编译成功会成为Outer.class和Outer&Inner.class两个类的字节码文件。
29.非静态内部类:(外部类里使用非静态内部类和平时使用其他类没什么不同)
- 非静态内部类对象必须寄存在一个外部类对象里,因此,如果有一个非静态内部类对象,那么一定存在对应的外部类对象,非静态内部类对象单独属于外部类的某个对象。
- 非静态内部类可以直接访问外部类的成员,但是外部类不能直接访问非静态内部类成员。
- 非静态内部类不能有静态方法,静态属性和静态初始化块。
30.成员变量访问要点:
- 内部类属性:this.变量名
- 外部类属性:外部类名.this.变量名
31.非静态内部类的访问:
- 外部类中定义内部类:new Inner();
- 外部类以外的地方使用非静态内部类:
Outer.Inner a = new Outer().new Inner();
32.静态内部类:
Static class ClassName{
//类体
}
使用要点:
- 静态内部类可以访问外部类的静态成员,不能访问外部类的普通成员。
- 静态内部类看做外部类的一个静态成员。
- 创建对象:外部类.内部类 对象 = new 外部类.内部类();
如:Outer.Inner a = new Outer.Inner();
33.数组:
- 数组也是对象;
- 数组是相同类型数据的有序集合;
- (1)System.arraycopy(被复制数组的名字,从下标哪里开始被复制,复制数组的名字,从下标哪里开始粘贴,复制粘贴的长度)、
- Array.toString(数组名)、
- Array.fill(开始下标,结束下标,数据替代值)、
- Array.binarySearch(数组名,要查找的数据值)
- Arrays.sort(数组名)
package TestJavaSE;
import java.util.Arrays;
public class ArrayTest01
public static void main(String[] args) {
String[] s = {"阿里","尚学堂","京东","搜狐","网易"};
String[] sBak = new String[6];
//数组的复制copy;
//System.arraycopy(被复制数组的名字,从下标哪里开始被复制,复制数组的名子,从哪里开始粘贴,复制粘贴的长度)
System.arraycopy(s,0,sBak,0,s.length);
for (int i = 0 ; i<sBak.length;i++){
System.out.println(sBak[i]+"\t");
}
int[] a = {1,2,323,23,53,12,59};
System.out.println(Arrays.toString(a));//Arrays.toString(数组名);将数组内容转换为列表的形式;
Arrays.sort(a);//将数组a的数据从小到大进行排序;
System.out.println(Arrays.toString(a));
//返回排序后新的索引位置,若未找到返回负数(不是负一);
System.out.println("该元素的索引:"+Arrays.binarySearch(a,120));//Arrays.binarySearch(查找的数组名,查找的数据值);
int[] b = {10,20,30,40,50};
Arrays.fill(b,2,4,100);//把下标为【2,4)的数据换成100;
System.out.println(Arrays.toString(b));
}
}
34.Object
- (1)Object是所有类的父类,所以用Object作为声明类型,数组中可以有不同类型的数据;
(2)如果把一维数组的数组名赋值给二维数组的某一行的话,是把一维数组的内容赋值给二维数组那一行;
(3)两个一维数组a1,a2,a1=a2,是把a2的地址赋值给了a1,a
1的地址指向a2的,所以a1的值也变成了a2的值;
package TestJavaSE;
import java.util.Arrays;
//测试Object[][]二维数组存储表格数据;
//Object是所有类的父类,用Object作为声明类型,数组中的数据可以有不同类型的数据;
//把一维数组的数组名赋值给二维数组的某一行,是将一维数组的数据赋值给二维数组的某一行;
//两个一维数组a1、a2,a1=a2的话;是把a2的地址赋值给a1;a1和a2有相同的数据;
public class ArrayTest03 {
public static void main(String[] args) {
Object[] a1 = {1001,"高小琪",18,"讲师","2-14"};
Object[] a2 = {1002,"高小七",19,"助教","2-15"};
Object[] a3 = {1003,"高小琴",20,"主任","2-16"};
Object[][] emps = new Object[3][];
emps[0] = a1;
emps[1] = a2;
emps[2] = a3;
System.out.println(Arrays.toString(emps[0]));
System.out.println(Arrays.toString(emps[1]));
System.out.println(Arrays.toString(emps[2]));
System.out.println("===================");
for(int i=0;i<emps.length;i++){
for (int j=0;j<emps[i].length;j++){
System.out.println(emps[i][j]+"\t");
}
System.out.println();
}
int[] a = {1,2,3,4};
int[] b = {4,5,6};
System.out.println(a);
System.out.println(b);
a = b;
System.out.println(a);
System.out.println(Arrays.toString(a));
}
}
35.使用javabean和数组结合保存表格数据
package TestJavaSE;
//使用Javabean和数组结合起来保存表格数据;
//javabean是特殊的类,必须具有无参数的构造器,所有的属性都是private的,通过提供setter和getter方法来实现对成员属性的访问。
//用类名声明数组,调用构造方法,并重写toString()方法,要打印几个数据就选择几个数据重写;
public class ArrayTest04 {
public static void main(String[] args) {
emp[] empss = {
new emp(1001, "高小琪", 18, "讲师"),
new emp(1002, "高小七", 19, "助教"),
new emp(1003, "高小琴", 20, "教授")
};
for(emp i:empss){
System.out.println(i);
}
}
}
class emp{
private int id;
private String name;
private int age;
private String job;
public emp(int id, String name, int age,String job) {
this.id = id;
this.name = name;
this.age = age;
this.job = job;
}
@Override
public String toString() {
return "emp{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", job='" + job + '\'' +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
}
36.return:
return只能出现在函数里,如果出现在上面实例里的for循环里就会报错,return出现在函数里的作用就是即使下面还有内容也不再继续往下执行了,最常见的就是在函数里判断参数是否符合要求。
37.冒泡排序、二分法查找:
1.冒泡排序:
package TestJavaSE;
import java.util.Arrays;
//测试冒泡排序
public class BubbleSortTest {
public static void main(String[] args) {
int[] values = {3,1,4,6,22,0,33,2,745,5,56,8};
System.out.println("values数组原始顺序:"+Arrays.toString(values));
bubbleSort(values);
}
public static void bubbleSort(int[] values){//把冒泡排序的方法设置成static静态的,不允许改变代码;
int temp;
for(int i=0;i<values.length;i++){
//定义一个布尔类型的变量,标记数组是否已到达有序状态;
boolean flag = true;
//内循环,每一趟循环都从数列的前两个元素开始进行比较,比较到无序数组的最后;
for (int j=0; j<values.length-1-i;j++){
//如果前一个元素大于后一个元素,则交换两元素的值;
if (values[j] > values[j+1]){
temp = values[j];
values[j] = values[j+1];
values[j+1] = temp;
//本趟发生了交换,表明该数组在本趟处于无序状态,需要继续比较;
flag = false;
}
}
//根据标记量的值判断数组是否有序,如果有序,则退出,无序,则继续循环;
if (flag){
break;
}
System.out.println((i+1)+"趟排序:"+ Arrays.toString(values));
}
}
}
2.二分法查找:
package TestJavaSE;
import java.util.Arrays;
//二分法查找;(折半查找)
public class BinarySearchTest {
public static void main(String[] args) {
int[] arr = {30,20,50,10,80,9,7,12,100,40,8};
int searchWord =40;//所要查找的数;
Arrays.sort(arr);//二分法查找之前,一定要对数组元素先进行排序!!!
System.out.println(Arrays.toString(arr));
System.out.println(searchWord+"元素的索引:"+binarySearch(arr,searchWord));
}
public static int binarySearch(int[] array,int value){
int low = 0;//low--high是查找区间,low开始位置,high结束位置;
int high = array.length - 1;
while(low <= high){
int middle = (low+high) / 2;
if(value == array[middle]){
return middle;
}
if (value < array[middle]){
high = middle-1;
}
if (value > array[middle]){
low = middle + 1;
}
}
return -1;//如果array数组中没有要查找的value值,则返回-1;
}
}
38.import包名导入:
- java会默认导入java.lang包下所有类,因此这些类我们可以直接使用
如:Math类、Object类、String类、StringBuffer类、Integer包装类、 Class类
- 如果导入两个不同包中的同名的类,只能用包名+类名来显示调用相关类:
如:java.util.Date data = new java.util.Date();
39.Integer包装类
方法 | 返回值 | 功能描述 |
byteValue() | byte | 以 byte 类型返回该 Integer 的值 |
intValue() | int | 以 int 型返回此 Integer 对象 |
zebra stripes | are neat | 以 int 型返回此 Integer 对象 |
toString() | String | 返回一个表示该 Integer 值的 String 对象 |
valueOf(String str) | Integer | 返回保存指定的 String 值的 Integer 对象 |
parseInt(String str) | int | 返回包含在由 str 指定的字符串中的数字的等价数值 |
40.String类
String类
方法 | 返回值 | 功能描述 |
indexOf(int ch) | int | 搜索字符 ch 第一次出现的位置 |
indexOf(String value) | int | 搜索字符串 value 第一次出现的位置 |
lastIndexOf(int ch) | int | 搜索字符ch最后一次出现的位置 |
lastIndexOf(String value) | int | 搜索字符串 value 最后一次出现的位置 |
substring(int index) | String | 提取从位置索引开始到结束的字符串 |
substring(int beginindex, int endindex) | String | 提取beginindex和endindex之间的字符串部分 |
trim() | String | 返回一个前后不含任何空格的调用字符串的副本,意思是把字符串前后的空格部分去除 |
StringBuffer类
StringBuffer 类是可变的。
方法 | 返回值 | 功能描述 |
insert(int offsetm,Object s) | StringBuffer | 在 offetm 的位置插入字符串s |
append(Object s) | StringBuffer | 在字符串末尾追加字符串s |
length() | int | 确定 StringBuffer 对象的长度 |
setCharAt(int pos,char ch) | void | 使用 ch 指定的新值设置 pos 指定的位置上的字符 |
toString() | String | 转换为字符串形式 |
reverse() | StringBuffer | 反转字符串 |
delete(int start, int end) | StringBuffer | 删除调用对象中从 start 位置开始直到 end 指定的索引(end-1)位置的字符序列 |
replace(int start, int end, String s) | StringBuffer | 使用一组字符替换另一组字符。将用替换字符串从 start 指定的位置开始替换,直到 end 指定的位置结束 |
Math类
方法 | 返回值 | 功能描述 |
sin(double numvalue) | double | 计算角 numvalue 的正弦值 |
cos(double numvalue) | double | 计算角 numvalue 的余弦值 |
acos(double numvalue) | double | 计算 numvalue 的反余弦 |
asin(double numvalue) | double | 计算 numvalue 的反正弦 |
atan(double numvalue) | double | 计算 numvalue 的反正切 |
pow(double a, double b) | double | 计算 a 的 b 次方 |
sqrt(double numvalue) | double | 计算给定值的平方根 |
abs(int numvalue) | int | 计算 int 类型值 numvalue 的绝对值,也接收 long、float 和 double 类型的参数 |
ceil(double numvalue) | double | 返回大于等于 numvalue 的最小整数值 |
floor(double numvalue) | double | 返回小于等于 numvalue 的最大整数值 |
max(int a, int b) | int | 返回 int 型 a 和 b 中的较大值,也接收 long、float 和 double 类型的参数 |
min(int a, int b) | int | 返回 a 和 b 中的较小值,也可接受 long、float 和 double 类型的参数 |
rint(double numvalue) | double | 返回最接近 numvalue 的整数值 |
round(arg) | arg 为 double 时返回 long,为 float 时返回 int | 返回最接近arg的整数值 |
random() | double | 返回一个介于0与1之间的伪随机数 |
Object类
方法 | 返回值 | 功能描述 |
equals(Objectobj) | boolean | 将当前对象实例与给定的对象进行比较,检查它们是否相等 |
finalize() throws Throwable | void | 当垃圾回收器确定不存在对象的更多引用时,由对象的垃圾回收器调用此方法。通常被子类重写 |
getClass() | Class | 返回当前对象的 Class 对象 |
toString() | String | 返回此对象的字符串表示 |
wait() throws InterruptedException | void | 使当前线程进入等待状态 |
未掌握的知识点
Window 10 截图快捷键:Win+Shift+S组合键
- System.eixt(0);退出当前系统。
- return 退出当前方法体,但不是退出系统。
- 当调用与被调用的方法在同一个类中,即调用本类的方法时,用this.方法名。千万不要实例化对象去调用。
- 调用collections工具类中的sort(1,2)方法,1中填入容器名,2中填入比较器对象;
如:collections.sort(this.list,new OrderByName());
- 类中定义了含参的构造方法,记得一定要放一个无参的构造方法。
/**
* 未掌握知识点:在main方法中,因为main方法是static静态方法,
* 而静态方法不能直接调用非静态方法,所以调用本类的非静态方法时不能用this调用
* 而要实例化对象来调用
*/
7.
/**未掌握:1.正则表达式是一个String对象的字符序列,所以对象只能是String类型,而
* 且matches()也只能对String类型进行比较
* 2.将Scanner对象定义在方法中,对象随着方法的死亡而死亡,定位全局变量的话,
* 随着类的凋亡而凋亡,浪费空间,所以应在方法中创建Scanner对象。
* 3.将String类型转为int类型,通过包装类中的parseInt()方法:
* 如:int num = Integer.parseInt(input);
*/
8.
/**
* 未掌握知识点:
* 正则表达式中:[1-9][0-9]和[1-9]{1}[0-9]{1}一样的意思,都是输入两个数!
* @return
*/
9.
/**
* 未掌握知识:这里的电话用String类型,因为int类型的话,
* 电话号的数值会溢出,而且座机号有-,int类型不支持,所以要用String类型
* @return
*/
10.
/**
* 未掌握知识点:list容器有索引,从0开始
* list.get()方法获取元素
*/