目录
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。