1、JavaSE里面最基础、最重要的基本知识就是变量,在这里给出关于变量我们需要掌握的知识。
变量 :
解决的是单个数据的存储问题.
存数据的一块空间
内存中的一块被命名的有特定类型约束的存储区域, 该区域中可以保存一个数据, 并且这个数据可以无限次地在其范围内被修改.
声明变量:类型 变量名;
初始化赋值, 变量刚声明完后的第一次赋值
变量名 = 值;
普通赋值:变量名 = 值;
变量的使用 :只需要通过变量名就可以了 不可以加双引号 "变量名"
变量的使用注意事项 :
1) 变量有作用范围 : 变量的声明语句所属的花括号
2) 变量必须有名字
3) 变量必须有类型
4) 保存的数据有其范围
5) 必须要有初始化值
6) 先声明,后使用
7) 变量在其范围内不可以重复定义
变量的分类
1) 按照数据类型
1) 基本数据类型 : 变量空间中保存的就是数据本身
1) 数值型
1) 整数
byte 1 -128~127
short 2 -32768~32767
int 4 -20多亿~20多亿
long 8 很大
2) 浮点数
float 4 10的38次方
double 8 10的300多次方
2) 字符型
char 2 0~65535
3) 布尔型
boolean 1 只有true或false
boolean b = true;
2) 引用数据类型 : 保存的是别的数据的地址
2) 按照变量的范围
1) 局部变量 : 在方法中声明的变量 范围小, 寿命短
2) 成员变量 : 在类中方法外声明的变量范围大, 寿命长
class A {
int i = 1; // 成员变量
void m() {
int i = 0; // 局部变量
}
}
2、关于变量就这些比较重要的知识点,接下来就是流程控制,主要包括分支语句和循环语句。
下面是需要掌握的
流程控制 :
分支 :
<span style="white-space:pre"> </span>/*if
if (A) {
B;
} else if (X) {
Y;
} else {
C;
}
switch
switch (变量) {
case 常量1 :
语句;
break;
case 常量2 :
语句2;
break;
...
default :
语句N;
break;
}*/
循环 :
<span style="white-space:pre"> </span>/*while 循环0-N次
while(条件) {
循环体;
}
while (true) { 死循环
循环体;
}
do while 循环1-N次
do {
循环体;
} while (条件);
do {
语句1;
语句2;
条件
break;
语句3
语句4
} while (false);
语句5
do {
} while (true); 死循环
适用于循环次数不确定的循环.
for 循环
for (初始化; 条件语句; 迭代语句) {
循环体;
}*/
死循环的多种写法:
for (;;) {}
for (初始化;;迭代语句) {}
for (初始化;true;迭代语句) {}
for (初始化; 条件语句;) {}
特殊流程控制语句 :
break 中断它所隶属的某个语句块的执行
break 标签; 中断标签指定的循环体
continue 中断当次循环, 直接进入下一次循环
while (条件) {
continue;
}
continue 标签 中断标签指定的循环的当次循环, 直接进入标签指定的循环的下一次循环.
这里我们还需要知道方法的声明:
<span style="white-space:pre"> </span>/*修饰符 返回值类型 方法名(形参类型1 形参1, 形参类型2 形参2, ....) {
方法体;
return 返回值类型的值;
}
API*/
public static Type methodName(Type1 parmeter1, Type2 parameter2, ....) {
code;
return value;
}
public static void anotherMethod() {
// 调用方法, 方法名(实参1, 实参2, ....);
Type var = methodName(argument1, argument2, ....);
}
// 只要能写语句的地方 就可以调用方法
public static int add(int a, int b) {
short c = (short)(a + b);
return c;
}
main() {
byte a = 10;
char b = 20;
int c = add(a, b);
}
3、现在开始进入Java的重头戏-面向对象,以及比较难的数组
用 对象属性(成员变量)或实例变量, 描述特征,
用 对象方法或实例方法来描述行为
<span style="white-space:pre"> </span>class ClassName {
// 对象属性 描述特征
private Type1 field1;
private Type2 field2 = value2; // 显式赋值
....
// get/set方法, 针对的是私有属性
public void setField1(Type1 field1) {
this.field1 = field1;
}
public Type1 getField1() {
return field1;
}
public void setField2(Type2 field2) {
this.field2 = field2;
}
public Type2 getField2() {
return field2;
}
// 对象方法 描述行为
修饰符 返回值 方法名(形参类型1 形参1, 形参类型2 形参2...) {
}
// 获取对象的详细信息
public String say() {
String str = "属性1的说明:" + field1 + ",属性2的说明:" + field3 + ....;
return str;
}
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>
对象 :是类的实例
<span style="white-space:pre"> </span>main() {
// 创建对象
ClassName 引用 = new ClassName();
//引用.field1 = value1;
引用.setField1(value1);
//引用.field2 = value22;
引用.setField2(value22);
System.out.println(引用.say());
}
创建对象
<span style="white-space:pre"> </span>main() {
类名 引用 = new 类名();
// 一个对象的创建过程
// 1) 在永久区中检查要创建的对象所属的类的类模板是否存在
// 2) 如果不存在, 则由类加载器执行加载(读取类.class文件), 如果存在, 则不加载了.
类模板(属性的定义和方法代码)
// 3) 依据类中的属性的定义,在GC区中开辟适当的空间
// 4) 把此空间清0
// 5) 如果有显式赋值,则执行显式赋值
// 6) 执行构造器,进一步初始化
// 7) 返回对象在GC区中的首地址
引用.成员名
}
接下来新手比较头疼的一部分:数组
声明 :元素的数据类型[] 数组名;
创建 :数组名 = new 元素的数据类型[长度]; // 动态创建
数组的静态创建:
元素数据类型[] 数组名 = {元素值1, 元素值2, 元素值3...}; // 只能用于声明和创建在同一条语句上.
元素数据类型[] 数组名 = new 元素数据类型[]{元素值1, 元素值2,....};
数组的动态创建:
元素类型[] 数组 = new 元素类型[长度]; // 如果是引用数组, 全部是空洞, 如果是基本类型数组,全部是0
数组元素的访问 :数组名[下标] = 值;
数组遍历 :
<span style="white-space:pre"> </span>/*for (int i = 0; i < 数组名.length; i++) {
System.out.println(数组名[i]);
}
for (元素类型 变量 : 数组名) {
访问变量相当于访问数组中每个元素值
}*/
基本用法:
<span style="white-space:pre"> </span>int[] arr = {3, 8, 2, 0, 9, 7, 4};
<span style="white-space:pre"> </span>
//增强型for循环
for (int var : arr) {
System.out.println(var);
}
//最大值
int max = arr[0];
for (int var : arr) {
if (var > max) {
max = var;
}
}
//下标法求最大值
int maxIndex = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > arr[maxIndex]) {
maxIndex = i;
}
}
int maxValue = arr[maxIndex];
// 检索元素值为70的下标
int key = 70;
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
index = i;
break;
}
}
if (index == -1) {
System.out.println("搜索的数据不存在");
} else {
System.out.println("下标是" + index);
}
// 取出数组中能被3整除的
int[] newArr = new int[arr.length];
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 3 == 0) {
newArr[count] = arr[i];
count++;
}
}
int[] child = new int[count];
for (int i = 0; i < count; i++) {
child[i] = newArr[i];
}
newArr = null;
// 扩容
int[] bigger = new int[比原来大];
for (int i = 0; i < arr.length; i++) {
bigger[i] = arr[i];
}
arr = bigger; // 如果是引用数组,则会产生大量的空洞
// 排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}