目录
1、注释
单行注释：ctrl+/ 快速单行注释
//这是一个单行注释多行注释：ctrl+shift+/ 快速多行注释
/*
*这是一个多行注释
*/文档注释：alt+shift+j 快速文档注释
/**
*这是一个文档注释
*@author 作者是
*@return 返回值是
*/2、关键字
具有特定功能的标识符
null,true,false 不是关键字
3、标识符
包名、类名、变量名以及方法名都被称为标识符
1、以字母、美元符、下划线、数字组成
2、数字不能开头
3、不能是关键字
PS：标识符是大小写敏感的
详见《阿里巴巴java开发手册终极版》
4、包
import java.util.Scanner；
//在当前文件中使用其他包中文件时，使用import除了java.lang
//import 全文件名（=全包名.文件名）
import java。util.*；
//引入util包中的所有文件
5、访问控制修饰符
public： 公有公共的修饰符，表示修饰的可以在当前工程的任何一个地方使用
6、class关键字
定义、声明一个类=class 类名｛类体｝
公有类的类名必须与文件名一致，且文件中只有一个公共类
7、标准输出
System.out.println("HelloWorld!");8、标准输入
//首先导入工具包
import java.util.Scanner;
Scanner cin=new Scanner(System.in);
int value=cin.nextInt();//输入value 的值
9.格式化
CTRL+shift+f 快速格式化
10、JDK、JRE、JVM
JDK中包含了JRE；JRE中包含了JVM，
当从零开始写java程序时，就需要JDK，而要运行已经存在的Java文件只需要有JRE就行。
11、关键字详细
| 类别 | 关键字 | 说明 |
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| 类，方法和变量修饰符 | class | 类 |
| abstract | 生命抽象 | |
| extends | 扩充继承 | |
| final | 最终值 | |
| implement | 实现（接口） | |
| interface | 接口 | |
| native | 本地原生方法（非java实现） | |
| new | 新，创建 | |
| static | 静态 | |
| strictfp | 严格，精准 | |
| synchronized | 线程同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一一个值以供switch选择 | |
| continue | 继续 | |
| default | 默认 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert | 断言表达式是否为真 |
| catch | 捕捉异常 | |
| throw | 抛出一个异常对象 | |
| finally | 有没有异常都执行 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 基本类型 | boolean | 布尔型 |
| byte | 字节型 | |
| char | 字符型 | |
| double | 双精度浮点 | |
| float | 单精度浮点 | |
| int | 整型 | |
| long | 长整型 | |
| short | 短整型 | |
| 变量引用 | super | 父类,超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 | |
| 字面常量 | null | 空 |
| true | 真 | |
| false | 假 | |
12、方法
返回类型 方法名称 （参数列表 ）{方法体}
void test(int a,int b){
System.out.println(a+b);
}方法定义:
简单格式: 返回类型 方法名称 (参数列表) {方法体}
参数列表: 参数类型1 参数名称1,参数类型 2 参数类型 2，....
变量定义:
简单格式: 变量类型 变量名称;
PS:
| 直接书写规则 | 定义类 | 定义方法 | 定义变量 |
| 类中 | 可以 | 可以 | 可以 |
| 方法中 | 可以 | 不可以 | 可以 |
相同范围内不能书写定义一模一样的内容，如:变量名/方法
成员变量(全局变量)--可以在多个方法中使用
//变量定义-简单格式规则:变量类型 变量名称;
int a1=2;
boolean b1=false;
String s1="abc";
//成员方法
//方法定义-简单格式:返回类型方法名称(参数列表){方法体}
String function1() {
//重名变量:遵循前置就近原则，即:使用的是之前最近定义的变量
System.out.println(s1);//先定义再使用ctrl+左键
String s1 = "abcdefg";// 局部变量--优先原则
System. out. println(s1);
return s1;13、静态方法：
不能直接使用实例方法，可以直接使用静态成员（静态方法）
public class Test01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner cin = new Scanner(System.in);
int a=cin.nextInt();
int b=cin.nextInt();
int max=max(a,b);
System.out.println(max);
}
public static int max(int a, int b) {
int max = a > b ? a : b;
System.out.println("最大值");
return max;
}
/*出错
public int max(int a, int b) {
int max = a > b ? a : b;
System.out.println("最大值");
return max;
}*/
}静态方法若想使用实例方法，则可以将类作为类型，进行实例化，通过实例化对象对方法进行调用。
public class Test01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test01 t1=new Test01();//构造方法的调用
Scanner cin = new Scanner(System.in);
int a=cin.nextInt();
int b=cin.nextInt();
int max=t1.max(a,b);
System.out.println(max);
}
public int max(int a, int b) {
int max = a > b ? a : b;
System.out.println("最大值");
return max;
}14、方法重载
方法的方法名一样，参数的个数不一样，类型不一样，顺序不一样
15、变量分类
实例变量(无static修饰)
局部变量(方法中的变量)
参数变量(形式参数/实际参数)
循环变量
作用范围(作用域) (先定义再使用)
局部变量:
方法执行时创建，方法执行完销毁。
方法或{范围内有效。
实例变量:
对象创建时创建，对象销毁时销毁。
类的范围内有效。
静态变量:
该类首次访问时创建，程序结束时销毁。
该类的任何对象共用同一静态变量。
PS:
访问修饰符不能用于局部变量，可以用于成员变量。
默认值
默认值(变量未被赋值时)
静态变量:类使用时具有默认值
实例变量:类实例化时具有默认值
局部变量没有默认值，所以局部变量声明后必须初始化，才可使用。
成员加载过程
静态成员:类被第一次使用时，会将静态成员的定义逐个加载到内存中，加载全部静态成员后，会逐行执行可执行成员，如，成员变量的(默认值)赋值和静态代码块。
实例成员:每次实例化时，会将实例成员的定义逐个加载到实例中，加载全部实例成员后，会逐行执行可执行成员，如，成员变量的(默认值)赋值和示例代码块。
变量使用(不考虑访问修饰符时)
类.静态变量
对象.实例变量
PS: (同- -类中)
静态方法中使用当前类的静态变量，且可省略“."以左。
非静态方法中使用当前类的成员变量，且可省略“.以左。
遵循“就近原则”
局部变量和实例变量重名时，局部变量和实例变量重名时，
若想使用实例变量，则使用该局部变量时加上"“this."
方法
Java语句的集合，-起执行实现相应功能。
方法分类
成员方法
静态方法
实例方法
构造方法
主方法
方法定义基础格式:
修饰符 返回类型 方法名(参数类型1 参数名1，参数类型2 参数名2...){
//方法体
return 返回值;
｝
PS:若返回类型是void,则return; 或省略return。
return作用:结束方法，返回结果。
方法调用格式：
方法名(实际参数) ;
方法调用(不考虑访问修饰符时)
类.静态方法
对象.实例方法
PS: (同- -类中)
静态方法中使用当前类的静态方法，且可省略“.以左。
非静态方法中使用当前类的成员方法，且可省略“. ”以左。
方法调用过程(本质作用)
执行所调用方法中的代码，方法结束后返回到调用位置执行之后代码
PS:若方法有返回类型，则可以接收返回该类型的数据。
参数(调用过程是将实际参数赋值给形式参数)
形式参数(定义时,声明的参数变量)
形式参数(定义时,声明的参数变量)
参数传递实际参数给形式参数赋值的过程)
值传递(实际参数和形式参数值相同的两个不同变量)
引用传递(实际参数和形式参数指向同地址的两个变量)
构造方法
类实例化对象时，构造方法用来初始化该对象(new)
构造方法和它所在类的名字相同，但构造方法没有返回类型。
没声明任何构造方法时可调用默认无参构造方法，否则默认构造方法失效。
15、变量
引用类型
基本数据类型：byte,
short ,
int ,
long,
float,
double,
char , ' '中间必须要放字符
boolean
//变量分类
// 1-引用类型
// 2-基本数据类型
//变量定义--简单格式:变量类型变量名称;
//赋值运算中赋的值如果是个常量会自动识别成所赋值的类型
byte bt1=0;// 字节
short st1=0;//短整型
int i1=0;//整型
long l1=0L;// 长整型
float f1=0.0f;//1单精度浮点类型--标志Ff Dd Ll
double d1=0.0D;= 0.0D; //双精度浮点类型
boolean bl1=false; //布尔--真true假false
char c1=' ';//字符型，单引号中必须只能含有一个字符
//普通字符: '' '-' '我’'A' '\n' '\u0061' (转义字符)
char c2 = 61;类型 字节 最小值 最大值 默认值 备注
| byte | 1 | 1 (-2^7) -128 | (2^7-1) 127 | 0 | |
| short | 2 | (-2^15) -32768 | (2^15-1) 32767 | 0 | |
| int | 4 | (-2*31) | (2^31- 1) | 0 | 整型变量默认类型 |
| long | 8 | (-2^63) | (2^63 -1) | 0L | L大小写都可 |
| float | 4 | +/-1.4E-45 | +/-3.4E+38 . | 0.0f | F大小写都可 |
| double | 8 | +/-4.9E-324 | +16-1.7E+308 | 0.0d | D大小写都可，浮点变量默认类型 |
| char | 2 | \u0000 (0) | \ufff (65535) | \u0000空格 | Unicode 字符、转义字符 |
| boolean | 1 | false | true | false |
PS:引用类型变量的默认值是null
自动类型转换：
1字节=8位二进制
1-自动类型转换=小范围变量转换成大范围变量
byte , short, char<int<long<float<double
//混合运算(浮点型、整型、常量、字符型数据) --统一成相同类型后运算
// 2-强制类型转换=大范围变量转换成小范围变量
i23+1进行运算时，需要进行强制类型转换。
强制转换时，会发生范围溢出和精度损失。
基本数据类型对应的引用类型：
Byte，Short， Integer，Long
Float、Double.
Character、Boolean
@Test
public void testBinarySystem() {
int i=10;
String b=Integer.toBinaryString(i);//十进制转换为二进制
System.out.println(b);
int x=10,y=012,z=0xA;//0.。。表示为八进制，0x。。。表示为十六进制
System.out.println(x);
System.out.println(y);
System.out.println(z);
}PS:区别:
基本数据类型:保存在栈内存中的简单数据，即这种值完全保存在内存中的一个位置。如: int i=2;
引用类型:保存在栈内存中的引用名指向保存在堆内存中的对象，类似-一个指针/地址。如: String s=new String("abc");
16、Junit技术
公有的+非静态的+无参的+void +无构造方法
@Test
public void main(){ }
调试时右击 run as ->junit
17、String 的APi
substring(1,4)//【1,4）截取之间的字符串
s1.compareTo（s2）//比较s1 s2的大小
isEmpty（） //字符串是否为空
trim（）//去掉首尾空格
length（）//字符串的长度
split（）
使用StringBuffer对字符串进行连接，是安全的
StringBuffer sb=new StringBuffer("10000");
sb.append(10.1);
System.out.println(sb);
//在sb参数的后面加上10.1； append方法的参数可以是各种类型（整型，浮点数，字符型，字符串型，字符数组，布尔类型，等
字符串内容倒置，使用双向索引的方式
@Test
public void testString05() {
//字符串倒置
char[] c="this is a centence".toCharArray();
for(int m=0,n=c.length-1;m<n;m++,n--) {
char temp=c[n];
c[n]=c[m];
c[m]=temp;
}
/*for(int m=0;m<c.length;m++) {
System.out.print(c[m]);
}*/
System.out.println(new String(c));
}字符串变量与整型变量的相互转换：
@Test
public void test06() {
//整型转字符串
String s1=1+"";
String s2=String.valueOf(1);
String s3=Integer.toString(1);
//字符串转整型
int i1=Integer.parseInt("1 ".trim());
int i2=Integer.valueOf("1");
int i3=Integer.valueOf("1").intValue();
}String 和 new String 的区别：
JVM为了提升性能和减少内存开销，避免字符串的重复创建，维护了一块特殊的内存空间——字符串实例池。
String赋值的两种方式。
1、String str = "test";
以这种方式赋值时，JVM会先从字符串实例池中查询是否存在"test"这个对象，
如果存在，直接把实例池中"test"的地址返回给str。如果不存在，则会在实例池中创建"test"对象，并把该对象的地址返回给str。
2、String str = new String("test");
以这种方式赋值时，JVM会先从字符串实例池中查询是否存在"test"这个对象，
若不存在则会在实例池中创建"test"对象，同时在堆中创建"test"这个对象，然后将堆中的这个对象的地址返回赋给引用str。
若实例池存在则直接在堆中创建"test"这个对象，然后将堆中的这个对象的地址返回赋给引用str。
1046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
