自学Java-0基础到框架(JDK8)-day03
1.修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端；
①访问控制修饰符
- default(变量和方法的声明不使用任何修饰符)：同一个包的类可以访问；(适用范围：类、接口、变量、方法)
- public 意味着任何地方的其他类都能访问；(适用范围：类、接口、变量、方法)
- protected 表示同一个包的类可以访问，其他的包的该类的子类也可以访问；(适用范围：变量、方法)
- private 表示只有自己类能访问(适用范围：变量、方法)
- 父类中声明为 public 的方法在子类中也必须为 public。
- 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
- 父类中声明为 private 的方法，不能够被子类继承。
②非访问修饰符
-
final: final 类不能被继承
-
- final方法表示可以被子类继承，但是不能被子类重写，主要目的是防止该方法的内容被修改。 适用范围：类、变量、方法
-
static: 可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）。 适用范围：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）
-
abstract: 表示是抽象类。 使用对象：类、接口、方法
抽象类：
>
> 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
>
> 一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
>
> 抽象类可以包含抽象方法和非抽象方法。
-
synchronized:该关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符，即放在四种访问修饰符前修饰
-
transient：
当对象被序列化（写入字节序列到目标文件）时，transient阻止实例中那些用此关键字声明的变量持久化；当对象被反序列化时（从源文件读取字节序列进行重构），这样的实例变量值不会被持久化和恢复。
>
> > 我认为意思就是修饰在包含定义变量的语句中时这个将不会被序列化存储在硬盘
-
volatile
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
>
> 一个 volatile 对象引用可能是 null。
>
> > 我认为就是它修饰在成员变量上，在多线程中访问该变量，都会重新从线程中获取，使真实数据可见。
目前后三种修饰词还没有理解他的意思，到后面慢慢理解
运算符
循环结构
while
while( 布尔表达式 ) {
//循环内容
}
例子
public class circle {
public static void main(String[] args) {
// while
int whileStart = 0;
int whileEnd = 10;
while (whileStart < whileEnd){
System.out.println("While int = "+whileStart);
whileStart++;
}
}
}
输出：
While int = 0
While int = 1
While int = 2
While int = 3
While int = 4
While int = 5
While int = 6
While int = 7
While int = 8
While int = 9
do...while
相比于While，这个循环至少循环一次
do {
//代码语句
}while(布尔表达式);
例子
public class circle {
public static void main(String[] args) {
//do...While
int doWhileStart = 0;
int doWhileEnd = 10;
do {
System.out.println("do...while Int = "+doWhileStart);
doWhileStart++;
}while (doWhileStart < doWhileEnd);
}
}
输出：
do...while Int = 0
do...while Int = 1
do...while Int = 2
do...while Int = 3
do...while Int = 4
do...while Int = 5
do...while Int = 6
do...while Int = 7
do...while Int = 8
do...while Int = 9
for
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
for(初始化; 布尔表达式; 更新) {
//代码语句
}
示例：
public class circle {
public static void main(String[] args) {
// for
int forEnd = 10;
for (int forStart = 0;forStart < forEnd;forStart++){
System.out.println("for Int = "+forStart);
}
}
}
输出：
for Int = 0
for Int = 1
for Int = 2
for Int = 3
for Int = 4
for Int = 5
for Int = 6
for Int = 7
for Int = 8
for Int = 9
Java 增强 for 循环
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
例子：
public class circle {
public static void main(String[] args) {
// 增强for循环
int [] numbers = {1,5,3,4,2,6,9,8,7};
for (int x : numbers){
System.out.println("增强 For循环 数值 = " + x);
}
}
}
输出：
增强 For循环 数值 = 1
增强 For循环 数值 = 5
增强 For循环 数值 = 3
增强 For循环 数值 = 4
增强 For循环 数值 = 2
增强 For循环 数值 = 6
增强 For循环 数值 = 9
增强 For循环 数值 = 8
增强 For循环 数值 = 7
switch case(分支语句)
- case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量
- 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句
- 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句
- default 分支可以不需要 break 语句
public class SwitchTest {
static char test = 'B';
public static void main(String[] args) {
switch (test)
{
case 'A':
System.out.println("A");
break;
case 'B':
System.out.println("B");
break;
case 'C':
System.out.println("C");
break;
default:
System.out.println("Wrong");
break;
}
}
}
输出：
B
continue语句
- 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代
break语句
- 主要作用于switch语句，跳出整个语句块
- 跳出最里层的循环，并且继续执行该循环下面的语句
发表于 2022-4-1 23:16
