java基础(个人学习笔记) A

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("最大值是\t"+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的值为\t"+a+"，b的值为\t"+b);

//交换

a = a + b;

b = a - b;//30 - 20;

a = a - b;

//交换后的结果

System.out.println("a的值为\t"+a+"，b的值为\t"+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+"\t");

//统计偶数个数

count++;

//每行输出5个 偶数个数==5时换行

if(count%5==0){

System.out.println();

}

}

//迭代条件

i++;

}while(i<=100);

//输出结果

System.out.println("1~100内偶数的个数是\t"+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的值\t"+num);//10

changeValue(num);

System.out.println("方法调用后num的值\t"+num);//10

}

public static void changeValue(int
num){//int num = num

num = 20;

System.out.println("方法调用中num的值\t"+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("方法调用前\t"+student[0]);//范冰冰

changeValue(student);

System.out.println("方法调用后\t"+student[0]);//周杰伦

}

//声明方法

public
static void changeValue(String[] student){

student[0]
= "周杰伦";

student[1]
= "周杰";

System.out.println("方法调用中\t"+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;

}

//输出解果

}

}