1. 声明long类型的变量 需要在数值的末尾+l/L。（不加L的话，貌似默认就是int型了。当给long赋值一个超过int范围的值的时候，会出问题。）
2. package java_study;
public class 你好{
public static void main(String
[] args){
/*
1.以字母,数字,下划线_,$
2.不能以数字开头
3.严格区分大小写
4.长度无限制
5.不能是java中的关键字
*/
System.out.println("汉字也能当类名");
}
}
3.
/*
跳转到对应的周几
技能：认识switch
switch(){
case 常量:
逻辑
break;
case 常量：
逻辑
break;
。。。。
default:
逻辑；
break;
总结：1.switch(表达式)byte short int char String enum(枚举)
2.case 后面必须是常量 固定的值
3.case 常量不能重复 错误: case 标签重复
4.default是可选的（可有可无的）
5.防止语句块之间的穿透
}
*/
4. /*
逻辑运算符：
&:两边的表达式都为true，结果才是true
&&:两边的表达式都为true，结果才是true,如果前面的表达式为false不再计算后面的表达式
|：两边的表达式一个为true，结果就是true
||:两边的表达式一个为true，结果就是true;
如果前面的表达式为true,不再计算后面的表达式
*/
class Home1{
public static void main(String []args){
//定义boolean类型的变量
int x = 3;
int y = 4;
boolean b1 = y > x | ++x >--y;
System.out.println(b1+" "+ x+" "+y);
x = 3;
y = 4;
b1 = y > x || ++x > --y;
System.out.println(b1+" "+ x+" "+y);
}
}
5.
//使用三目运算符，写出3个数内的最大数
import java.util.*;
class Home2{
public static void main(String []args){
//创建对象
Scanner input = new Scanner(System.in);
//创建3个数用于比较
System.out.println("请输入第1个数");
int num1 = input.nextInt();
System.out.println("请输入第2个数");
int num2 = input.nextInt();
System.out.println("请输入第3个数");
int num3 = input.nextInt();
//比较
//int d = num1>num2?num1:num2;
//int maxNum = d>num3?d:num3;
// X ? Y Z
int maxNum = num1 > num2 ?(num1 > num3 ? num1 : num3):(num2 > num3 ? num2 : num3);
//输出结果
System.out.println("最大值是 "+maxNum);
}
}
6. /*
交换两个数的位置
5 = 2 + 3;
2 = 5 - 3;
3 = 5 - 2;
*/
class Home3{
public static void main(String []args){
//定义两个数
int a = 10;
int b = 20;
//输出交换前的结果
System.out.println("a的值为 "+a+"，b的值为 "+b);
//交换
a = a + b;
b = a - b;//30 - 20;
a = a - b;
//交换后的结果
System.out.println("a的值为 "+a+"，b的值为 "+b);
}
}
7. 一，如何拿到char类型的数据
字符串.charAt(index);下标0开始
String s ="我是中国人";
char c = s.charAt(2);
二，循环
1.求偶数的和
2.每行输出5个
1.初始化条件：执行一次并且不能省略
2.循环条件：while ,do{}while();是否可以省略; boolean类型
3.循环体
4.迭代条件：死循环
1
while(2){
3
4
}
1
do{
3
4
即使初始化条件不满足循环条件，也会执行一次循环体
}while(2);
for(1;2;4){
3
}
流程控制语句：
break:结束循环
continue:结束本次循环并继续执行下一次循环
return:结束一个方法
三，嵌套循环：将一个循环作为另一个循环的循环体
*******
*******
*******
外层控制行数
内层控制列数
8. /*
do｛｝while;
输出1~100内的偶数，每行输出5个
2,4,6,8,10
12,14,16,18,20
1.判断是不不是偶数
2.统计偶数的个数
*/
class DoWhileTest2{
public static void main(String [] args){
//定义一个变量，初始化条件
int i = 1;
//定义变量统计个数
int count = 0;
do{
//循环体
if(i%2==0){
//print不换行
System.out.print(i+" ");
//统计偶数个数
count++;
//每行输出5个 偶数个数==5时换行
if(count%5==0){
System.out.println();
}
}
//迭代条件
i++;
}while(i<=100);
//输出结果
System.out.println("1~100内偶数的个数是 "+count);
}
}
9. /*
流程控制语句
break:结束循环 END
continue：结束本次循环，继续循环 END
return：结束一个方法
注意：流程控制语句下不能写逻辑
无法访问的语句
*/
class LoopTest{
public static void main(String [] args){
for(int i = 1;i<=10;i++){
if(i==5){
//break;
continue;
//return;
System.out.println("如果能输出，给你一百万！！");
}
System.out.println(i);
}
System.out.println("END");
}
}
10.eclipse里 main Alt +/ 快捷输入 Sysout
F3 查看源码 Alt+←返回
11.
1.增强for循环和iterator遍历的效果是一样的，也就说
增强for循环的内部也就是调用iteratoer实现的(可以查看编译后的文件)，但是增强for循环 有些缺点，例如不能在增强循环里动态的删除集合内容。不能获取下标等。
2.ArrayList由于使用数组实现，因此下标明确，最好使用普通循环。
3.而对于 LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用 增强for循环，也就是iterator。
/*
数组的遍历
数组的有序指的是索引的顺序
两种循环对比：
1.增强for循环
for(数据类型标识符:数组名){
System.out.println(标识符);
}
简单
2.普通循环 能够操作下标
*/
class Arrays2{
public static void main(String [] args){
//定义一个数组
int [] arr = {12,45,23,10,98,78,100};
//arr[0],arr[1],
//遍历方式一
for(int i = 0;i<arr.length;i++){//0~6
System.out.println(arr[i]);
}
//第二种方式增强for循环
for(int num:arr){
System.out.println(num);
}
}
}
12. class ValueTest1{
public static void main(String [] args){
int num = 10;
System.out.println("方法调用前num的值 "+num);//10
changeValue(num);
System.out.println("方法调用后num的值 "+num);//10
}
public static void changeValue(int num){//int num = num
num = 20;
System.out.println("方法调用中num的值 "+num);//20
}
}
13.
class ValueTest2{
public static void main(String [] args){
String []student = new String[3];
for(int i = 0;i<student.length;i++){
student[i] = "范冰冰";
}
int num = 10;
for(String s:student){
System.out.println(s);
}
System.out.println("方法调用前 "+student[0]);//范冰冰
changeValue(student);
System.out.println("方法调用后 "+student[0]);//周杰伦
}
//声明方法
public static void changeValue(String[] student){
student[0] = "周杰伦";
student[1] = "周杰";
System.out.println("方法调用中 "+student[0]);//周杰伦
}
}
总结：
1、对于基本类型参数，在方法体内对参数进行重新赋值，并不会改变原有变量的值。
2、对于引用类型参数，在方法体内对参数进行重新赋予引用，并不会改变原有变量所持有的引用。
3、方法体内对参数进行运算，不影响原有变量的值。
4、方法体内对参数所指向对象的属性进行操作，将改变原有变量所指向对象的属性值。
也就是说，对于基本数据类型，实现的是传值，只是个形参，不会改变原有值。对于引用数据类型，对这个引用进行操作，其实也是相当于对形参的操作，不会改变原来的引用。但是，当对这个引用的属性进行操作的时候，相当于CPP中的传址调用，可以改变这个引用的属性的值。
Eg:
public class Main {
private static void getMiddleOne(boolean b, Boolean boo, Boolean[] arr){
b = true; //形参，不会改变原有值
boo = new Boolean(true); //引用变量的直接操作相当于值传递，不会改变原来的引用变量
arr[0] = true; //引用变量的属性的操作，会改变原有引用的属性，相当于传址调用
}
//测试
public static void main(String[] args) {
boolean b = false;
Boolean boo = new Boolean(false);
Boolean[] arr = new Boolean[]{false};
getMiddleOne(b, boo, arr);
System.out.println(b);
System.out.println(boo.toString());
System.out.println(arr[0]);
/**
* output:
* false
* false
* true
*/
}
}
14.
/*
流程控制语句深入
在循环外侧+label(可以自定义)
break label：label在哪里就结束哪层循环
continue:结束内层循环，继续外层循环
1234 1234 1234 1234 1234 1234 1234 1234 1234 1234
*/
class BreakTest{
public static void main(String [] args){
label:for(int i = 1;i<=10;i++){
for(int j = 1;j<=10;j++){
if(j==5){
//break ;
continue label;
}
System.out.print(j);
}
System.out.println();
}
}
}
15.
class JinZhi{
/*
将一个10进制的数转为二进制数
1.定义一个10进制数
2.除以2取余数 取商
3.将商作为被除数继续 取余数，取商
4.当商为0时终止
5.注意：result类型为String
*/
public static void main(String [] args){
//定义一个数
int num = 6;//110
String result = "";
//处理逻辑
while(num!=0){
//取余数
int yuShu = num%2;//0 , 1, 1
//让最后输出（最新的数据）的位于字符串的最前面
result = yuShu+result;//0+
System.out.println(result);
//取商
int shang = num/2;
//将商作为被除数
num = shang;
}
//输出解果
}
}