java基础(我的学习笔记) A

时间 2019-12-14

标签 java 基础我的学习笔记栏目 Java 繁體版

原文原文链接

1. 声明long类型的变量须要在数值的末尾+l/L。（不加L的话，貌似默认就是int型了。当给long赋值一个超过int范围的值的时候，会出问题。）java

2. package java_study;

public class 你好{

    public static void main(String [] args){
   /*
   1.以字母,数字,下划线_,$
   2.不能以数字开头
   3.严格区分大小写
   4.长度无限制
   5.不能是java中的关键字
      */
        System.out.println("汉字也能当类名");

    }
}数组

3. eclipse

/*oop

跳转到对应的周几测试

技能：认识switch对象

switch(){索引

case 常量:ip

逻辑字符串

break;get

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);

}

//使用三目运算符，写出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.迭代条件：死循环

while(2){

}

do{

即便初始化条件不知足循环条件，也会执行一次循环体

}while(2);

for(1;2;4){

}

流程控制语句：

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

* 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;

}

//输出解果

}