import java.util.Scanner;
public class HelloWord {
public static void main(String[] args) {
var scanner = new Scanner(System.in);
//int a = Integer.parseInt(scanner.nextLine());
//int b = Integer.parseInt(scanner.nextLine());
//1. 输入输出
int a = scanner.nextInt();
int b = scanner.nextInt();
System.out.println(a + b);
//2.数据类型
//简单数据类型 byte short int long float double boolean char
byte c = 10;
short d = 5;
int e = 20;
long f = 20;
float g = 19.0234f;
double h = 20.03434;
boolean i = Boolean.getBoolean(String.valueOf(c + d));
char j = 'j';
System.out.println(c + d + e + f + g + h + j);
if (i) {
System.out.println("是真的");
}
//3.变量类型 RunTest
//局部变量:定义在方法、构造方法或语句块中的变量,作用域为当前方法、构造方法或语句块,局部变量只能在使用前声明,不能被访问修饰修饰
//成员变量:定义在类中,方法之外,作用域为整个类,可以被类中任何方法和语句块访问。可以被访问修饰符修饰
//静态变量(类变量):定义在类中,方法之外,使用static修饰,作用域为整个类,可以被类中任何方法和语句块访问。静态变量的值在程序运行期间只有一个副本。静态变量可以被访问修饰符修饰。
/*参数变量(Parameters):方法定义时声明的变量,作为调用该方法时传递给方法的值。参数变量的作用域只限于方法内部。
值传递:值传递在方法调用时,方法定义时声明的变量传递的是实际参数的值的副本。当参数变量被赋予新的值时,只会修改副本的值,不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
引用传递:在方法调用时,传递的是实际参数的引用(即内存地址)。当参数变量被赋予新的值时,会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。*/
RunTest runTest = new RunTest();
runTest.method(20);
runTest.method2();
//4.java修饰符
//访问控制修饰符:
//default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
//private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)可以修饰内部类
//public : 对所有类可见。使用对象:类、接口、变量、方法
//protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)可以修饰内部类。
/*注意事项:
Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类;
接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public;
类和接口不能声明为 private;
类所有的公有方法和变量都能被其子类继承;
接口及接口的成员变量和成员方法不能声明为 protected;
子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;
子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。*///
//非访问修饰符:
//static 修饰符,用来修饰类方法和类变量。
//final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。
//abstract 修饰符,用来创建抽象类和抽象方法。
//synchronized 和 volatile 修饰符,主要用于线程的编程。
//synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
/*被 final 修饰的实例变量必须显式指定初始值。
声明 final 方法的主要目的是防止该方法的内容被修改
final 类不能被继承,没有类能够继承 final 类的任何特性
一个类不能同时被 abstract 和 final 修饰
如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
抽象方法是一种没有任何实现的方法,该方法的具体实现由子类提供。抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法示例:public abstract sample();。*/
//transient修饰符:序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
//volatile修饰符
//5.java运算符
//算术运算符:
System.out.println(c+d);
System.out.println(c-d);
System.out.println(c*d);
System.out.println(c/d--);
System.out.println(d%++c);
//++c先自加再运算 c--运算再自减
//关系运算符:
/* == != > < >= <= */
if (a == b ) {
System.out.println("a=b");
}
//位运算符:
/* & | ^ ~ << >> >>> 二进制按位运算 */
//逻辑运算符:
// &&逻辑与 当且仅当两个操作数都为真,条件才为真。
// ||逻辑或 用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。
// !逻辑非 用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。
boolean num1 = Boolean.parseBoolean(scanner.nextLine());
boolean num2 = Boolean.parseBoolean(scanner.nextLine());
System.out.println("a && b = " + (num1&&num2));
System.out.println("a || b = " + (num1||num2) );
System.out.println("!(a && b) = " + !(num1 && num2));
//赋值运算符:
/* = 简单的赋值运算符,将右操作数的值赋给左侧操作数
+= 加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数
-+ *= /=
<<= >>= 左(右)移位赋值运算符
&= |= ^= 按位与(或)(异或)赋值运算符*/
//条件运算符(三元运算符):
String ifNum = num1 == num2 ? "是": "不是";
System.out.println(ifNum);
//instanceof 运算符: 该运算符用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型)。
String name = "dove";
boolean result = name instanceof String;
System.out.println(result);
}
}
class RunTest {
//成员变量
private int instanceVar;
//静态变量
private static int staticVar;
public void method(int paramVar) {
//局部变量
int localVar = 10;
//使用变量
instanceVar = localVar;
staticVar = paramVar;
System.out.println("成员变量:" + instanceVar);
System.out.println("静态变量: " + staticVar);
System.out.println("参数变量: " + paramVar);
System.out.println("局部变量: " + localVar);
}
void method2() {
//使用类名访问静态变量
System.out.println(RunTest.staticVar);
//使用对象访问成员变量 this指向当前类的对象
System.out.println(this.instanceVar);
}
}
import java.util.Scanner;
public class Study {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//6.java循环结构
//while循环 只要布尔表达式为 true,循环就会一直执行下去。
int x = 1;
while (x < 5) {
System.out.println("while循环");
x++;
}
//do while循环 对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
do {
System.out.println("do while循环");
x++;
} while (x < 5);
//for循环 虽然所有循环结构都可以用 while 或者 do...while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。
for (int i = 1, j = 2; i < 10; i++) {
if (j < 8) {
break; //使用break跳出循环
}
if (i == 5) {
continue;//使用continue跳到下一次循环
}
System.out.println("for循环");
i++;
}
//Java5 引入了一种主要用于数组的增强型 for 循环
int[] nums = {10, 20, 30, 40, 50};
for (int k : nums) {
System.out.println(k);
System.out.println(","); //10,20,30,40,50,
}
//7.条件语句 if语句可以嵌套
int m = 10;
if (m < 20) {
System.out.print("这是 if 语句");
}
else{
System.out.print("这是 else 语句");
}
//switch case
var value = "value";
switch(value){
case "value" :
System.out.println("对的");
break;
case "val" :
System.out.println("不对");
break;
default :
System.out.println("都不是");
}
}
}