基础JAVA课堂笔记
java基础知识点笔记
java基础知识点笔记Java是一门非常重要的计算机语言，具有良好的跨平台性和易读性和易学性。
尤其是基于Java开发的移动端和Web端产品，其优秀的性能和可扩展性在行业中得到了广泛的青睐。
作为Java开发工程师，熟练掌握Java的基础知识非常重要。
一、Java基本语法Java程序包含一个或多个类，不同类可以相互调用使用。
每一个Java程序都需要有一个入口点，即main()函数。
在Java中，注释采用“//”或“/*...*/”的形式，可以单行或多行注释。
Java变量需要先声明再使用，可以定义基本类型变量和引用类型变量。
Java中的运算符包括算术运算符、逻辑运算符等。
二、Java面向对象编程Java是一门面向对象的编程语言，对象是Java程序的基本组成单元。
Java中的类封装了数据和方法，可以实现类的继承和多态。
在Java中，使用构造函数实例化对象，可以使用访问控制符来控制类成员的访问权限。
三、Java流程控制语句Java中的流程控制语句有条件语句（if、if-else、switch）、循环语句（while、do-while、for）等。
其中，if语句可以进行嵌套，switch语句可以使用break语句避免case穿透问题。
四、Java数组Java中的数组是一组相同类型的数据序列，从0开始编号，使用方括号表示。
在Java中可以使用foreach来遍历数组，也支持多维数组。
五、Java异常处理Java程序中的异常指的是程序出现的错误。
异常处理是Java程序中的一部分，可以使用try-catch语句来捕获并处理异常。
Java中的异常类型包括运行时异常和受检查异常。
六、Javaio编程Java中的文件和I/O操作称为io编程。
Java的io编程采用字节流和字符流，其中字节流用于处理二进制数据，字符流用于处理文本数据。
Java中的io操作需要进行文件的读取、写入等操作，可以使用File类来操作文件。
七、Java线程Java程序中，线程指的是一条执行序列，Java中的线程可以继承Thread类或实现Runnable接口。
java-课堂笔记-第一章至第八章知识点梳理
Java-课堂笔记-第一章至第八章知识点梳理1.控制台程序开发1.1 开发Java程序的步骤（1）编写源程序：Java源程序文件后缀名.java（2）编译源程序：使用javac命令编译源程序，编译之后的文件后缀名.class （3）运行使用java命令运行编译之后的.class文件1.2 程序开发环境记事本、Eclipse或MyEclipse1.3 控制台输入/输出（1）从控制台输入信息使用Scanner对象第一步：创建一个Scanner扫描器对象Scanner input = new Scanner(System.in);第二步：导入Scanner包import java.util.Scanner;第三步：获取从控制台输入的整数int num = input.nextInt();获取从控制台输入的小数double num = input.nextDouble();获取从控制台输入的字符char ziFu = input.next().charAt(0);获取从控制台输入的字符串String str = input.next();（2）从控制台输出信息使用System.out.print();System.out.println();转义字符：\n：换行\t：一个制表符（8个空格）1.4 程序注释Java中的注释有3种：（1）单行注释：//这里是注释内容（2）多行注释：/*这里是注释内容*/（3）文档注释：/**这里是注释内容*/1.5 程序调试2.变量和运算符2.1 变量变量：变量就是变化的量，是数据存储空间的表示，即数据在内存空间地址的别名（1）变量的声明语法：数据类型变量名;举例：int score;//声明一个int类型的变量score，保存成绩（2）变量的赋值（初始化）基本数据类型的赋值使用“=”赋值语法：变量名 = 值；举例：score = 98；引用数据类型使用new关键字语法：数据类型变量名 = new 数据类型（）；举例：Scanner input = new Scanner(System.in);2.2 常量2.3 运算符（1）赋值运算符：=、+=、-=、*=、/=、%=举例：sum += i;//相当于sum = sum + i;（2）算术运算符：+、-、*、/、%（3）关系运算符：>、<、>=、<=、==、!=（4）逻辑运算符：&&、||、!（5）自增运算符：i++或++ii++ 相当于 i = i + 1;（6）自减运算符：i--或--ii-- 相当于 i = i - 1;（7）三目运算符：?:3.数据类型与数组3.1 数据类型（1）基本数据类型整型：byte、short、int、long浮点型：float、double字符型：char布尔型：boolean（2）引用数据类型String、数组、类（class）、接口（3）数据类型转换自动数据类型转换自动数据类型转换的条件1.目标类型和源类型数据类型要兼容，数值类型（整型和浮点型）相互兼容2.目标类型要大于源类型，double型可以存放int型数据，因为double型变量分配的空间宽度足够存储int型变量强制数据类型转换语法：（数据类型）表达式；3.2 数组（1）数组的基本用法数组声明语法：数据类型[] 数组名;或数据类型数组名[];数组分配空间语法：数组名 = new 数据类型[数组长度];数组赋值静态赋值：给数组元素单个赋值如：scores[0] = 98;scores[1] = 87;动态赋值：使用for循环动态给数组元素赋值如：for(int i=0;i<scores.length;i++){ //每次循环把输入的数值赋值给数组元素scores[i] = input.nextDouble();}直接创建数组：方式一：数据类型[] 数组名={值1，值2，值3，....}；方式二：数据类型[] 数组名=new 数据类型[]{值1，值2，值3，..};访问数组元素：语法：数组名[下标值];获取数组长度：语法：数组名.length;（2）数组应用数组排序：1.import java.util.Arrays;//导入Arrays工具包2.Arrays.sort(数组名);求最大值：（见第七章数组课堂笔记）求最小值：（见第七章数组课堂笔记）4.流程控制语句4.1 分支结构（选择结构）（1）if选择结构if(判断条件){执行语句；}（2）if-else选择结构if(判断条件){执行语句1；}else{执行语句2；}（3）多重if选择结构if(判断条件1){执行语句1；}else if(判断条件2){执行语句2；}else if(判断条件3){执行语句3；}else{执行语句4；}（4）嵌套if选择结构if(判断条件1){if(判断条件2){执行语句1；}else{执行语句2；}}else{执行语句3；}（5）switch选择结构switch(表达式){case 常量1:代码块1；break;case 常量2:代码块2；break;case 常量3:代码块3；break;.......default:代码块n；break;}4.2 循环结构（1）while循环while(循环条件){循环操作；}特点：先判断，后执行（2）do-while循环do{循环操作；}while(循环条件);特点：先执行，后判断（3）for循环for(循环初始变量;循环条件;循环变量的更新){循环操作；}循环次数固定的时候，优先选用for循环while、do-while、for三种循环的对比，需要重点看下4.3 跳转语句（1）break用在switch选择结构中，表示跳出switch选择结构用在循环结构中，表示跳出整个循环或结束整个循环用在二重循环结构中，表示结束内层循环，继续执行外层循环（2）continuecontinue只能用在循环结构中，表示结束本次循环，进入下一次循环用在二重循环结构中，表示结束内层循环的本次循环，进入下一次循环（3）return。
第一章-Java基础笔记
第⼀章-Java基础笔记Java语⾔的概述Java是⼀门⾯向对象的语⾔,Java相对于C语⾔来说学习相对简单,它主要的三⼤特点就是:封装、继承、多态,并且只需要进⾏⼀次源码编译,在任何装有对应版本的JVM 虚拟机环境的计算机下运⾏;Java的三个版本JavaSE主要⽤于桌⾯应⽤的开发JavaME主要⽤于嵌⼊式系统的开发JavaEE主要⽤于企业级的WEB端开发和服务器开发Java环境介绍JDK - 提供了开发者的⼀些⼯具包,并包含了[JRE和JVM]JRE - Java的运⾏环境,提供了运⾏时需要的类库,并包含了[JVM]JVM - Java的虚拟⼀块内存区域,⽤于执⾏Java的代码Java跨平台交互图Java代码的运⾏机制后缀点java的⽂件会通过 javac命令进⾏⽂件的编译成⼀个能够被JVM读懂的字节码⽂件,通过加载、校验、初始化的过程都内存中，通过JVM寄存器读取⽂件中的⾏号，进⾏执⾏相关代码；注释注释是为了在编写程序时对某个类、⽅法或是⼀段代码进⾏功能作⽤的说明，它不会被编译成代码执⾏，只是起到⼀个描述作⽤，便于对代码的理解；Java中的注释分为3种：单⾏注释：//多⾏注释：/* */⽂档注释：/** */对注解的内容⽣成JavaDoc⽂档DOS命令进⼊到要⽣成Doc⽂档的层级⽬录,执⾏:javadoc -encoding UTF-8 -charset UTF-8 ⽂件名称/*** @Author JavaCat7* @Description 这是⼀个⽂档注释*/public class Demo{/*** @Parameter args 对参数的描述* @Description 这是⼀个⽂档注释*/public static void main(String[] args){//这是⼀个单⾏注释System.out.println("Hello Java");/*这是多⾏注释这是多⾏注释*/}}标识符每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；规范：每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；**规范：**1.严格区分⼤⼩写；2.开头可以是$ 或 _ 或 A-Z a-z的字母组成,也可以汉字(不会这么⼲);3.可以由数字、字母或者是 $ 或 _ 组成，但数字不能⽤于开始；4.不可以包含特殊字符；5.不能以Java语⾔中的保留字作为命名；6.类名采取⼤驼峰命名法;7.⽅法和变量采取⼩驼峰命名法;8.常量采取⼤学加_进⾏命名;基本数据类型Java是强类型计算机语⾔,所有的变量必须先定义才能使⽤,对于强类型⽽⾔主要就是指的数据安全,强类型的语⾔有很多,⽐如C、C++、python...计算机存储单位换算bit(位) - 是计算内部数据存储的最⼩单元,通过8个⼆进制位进⾏表⽰;byte(字节) - 是计算机中数据处理的基本单位,通常使⽤B来表⽰;8个bit(位) = 1B(字节)1024个B(字节) = 1KB1024个KB = 1MB1024个MB = 1GB....//整数类型byte a = 1;short b = 2;int c = 3;long d = 4L;//⼩数类型float e = 5.0f;duble f = 6.0d;//字符类型char g = 'a';//布尔类型boolean h = true;boolean i = false;数据类型的转换各数值相关数据类型⽀持类型上的转换,既可以把排序级别较低的类型转换成排序级别较⼤的类型,也可以把排序级别较⾼的类型转换成级别较低的类型(但会造成数据的丢失);数据的转换强制类型转换 - 在要转换的变量前使⽤:要转换的对应数据类型如- (int)⾃动类型转换 - 在不同的数值数据类型运算中,它会以排序级别较⾼的数据类型作为基础⾃动转换int number1 = 128;//正常byte的值是 -128 - 127,强制把int类型转换成byte会造成数据的不精确byte number2 = (byte)number1;int number3 = 519;float number4 = 1.0f;//在运算过程中因为float的排序级别⽐int⾼,那么它会⾃动转换成float类型在完成运算float number5 = number3 + number4;变量,静态变量,常量及作⽤域变量是指可以变化的值,通过数据类型和变量名可以在内存中申请⼀块存储的空间,通过内存的引⽤地址可以设置改变内存中存储的值或者修改值,所有的变量必须先赋值才可以使⽤;成员变量成员变量是指在类中与⽅法同级的位置中定义的成员变量,在该位置定义的变量可以不⽤设置值就可以使⽤,因为它会对类进⾏初始化,并完成初始化赋值,就算不给他们赋值也会有默认的初始值,他们的默认初始值都是最⼩的单元;作⽤域成员位置的变量,可以在⾮静态⽅法的所有位置使⽤,如果要在静态⽅法中使⽤,需要先创建对象;public class Variable{int a; //默认为:0float b; //默认为:0.0char c; //默认为:''boolean d; //默认为:false}局部变量局部变量是指在⽅法内部定义的变量,必须要先完成初始化后,才可以被使⽤;作⽤域局部位置的变量,外部⽆法使⽤,只能在⽅法内部使⽤,可以和外部的变量名称相同;public class Variable{int number;public void method(){int number = 3;//可以和成员位置的变量名称相同}}静态变量静态变量是指被static关键字修饰的变量,被修饰的变量⼜称为类变量;作⽤域静态变量可以作⽤域与所有⽅法中,静态变量只能定义在类的成员位置;public class Variable{static int number ;public static void main(String[] arags){System.out.println(number);}public void method(){System.out.println(numbe);}}常量常量是指不能被改变的值,它在创建到成员位置必须要先完成赋值,⼀旦被创建它的值是不允许被更改的;作⽤域它的作⽤域和成员变量相同public class Variable{final int NUMBER = 3.1415926;}静态常量静态常量是指从属于类的常量,在完成初始化以后是不可以被修改的,并且被public所进⾏修饰;作⽤域它的作⽤域和静态变量相同运算符算术运算符int a = 5;int b = 2;int number = a + b; //number = 7;int number = b - a; //number = 3;int number = a * b; //number = 10;int number = a / b; //number = 2,只取整数;double number = a / (double)b; //number = 2.5int number = a % b; //number = 1;⾃增⾃减运算符int a = 1;int b;b = a++; //b = 1; 先把a的值赋值给b,后a进⾏ +1 操作;b = a--; //b = 2; a前⾯进⾏了⾃增那么就是2,先把2赋值给b,然后进⾏ -1 操作;b = ++a; //b = 2; 前⾯a进⾏了⾃减那么就是1,先对a进⾏⾃增加1,然后在赋值给b;b = --a; //b = 1; 前⾯a是2,先对a进⾏⾃减1,在赋值给b;赋值运算符int a = 5;//把 5 赋值给 a;int b = 2;//把 2 赋值给 b;a += b; // a = 7(a+b的结果在赋值给a);a -= b; // a = 3;a *= b; // a = 10;a /= b; // a = 2;a %= b; // a = 1;关系运算符int a = 5;int b = 2;a > b; //truea < b; //falsea >= b; //falsea <= b; //truea == b; //falsea != b; //true逻辑运算符boolean a = true;boolean b = false;a &&b = false;//都true则true,第⼀个条件为false就不会在看第⼆个条件,直接返回falsea ||b = true;//⼀个条件为true则true,第⼀个条件为tre就不看第⼆个条件,直接返回true! a = false;//取反a &b = false;//2个条件都要执⾏a |b = true;三元运算符int a = 5;int b = 5;a ==b ? "等于":"不等于"; //为true返回第⼀个,为false返回第⼆个流程控制语句If语句if语句就是判断条件是否成⽴,成⽴就执⾏if中的代码,不成⽴就不进⼊;boolean flag = true;if(flag){System.out.println("...");}if...else语句if...else语句就是根据判断的条件是否成⽴,成⽴⾛if语句,不成⽴⾛else语句;boolean flag = true;if(flag){System.out.println("成⽴");}else{System.out.println("不成⽴");}if...else if语句if...else if⽀持多条件的判断,只会进⼊⼀个匹配的条件;boolean flag = true;boolean fail = false;if(flag){System.out.println("条件匹配");}else if(fail){System.out.println("条件匹配");}else{System.out.println("条件都不匹配");}switch条件控制语句witch语句从JDK1.7开始可以⽀持匹配:String字符串；注意事项:每个case 后⾯必须跟⼀个数值常量或字符串常量⽤于匹配;匹配的语句后⾯需要加上break关键字,防⽌case穿透;String week = "星期⼀";switch(week){case "星期⼀":System.out.println("今天是星期⼀");break;case "星期⼆":System.out.println("今天是星期⼆");break;case "星期三":System.out.println("今天是星期⼆");break;default:System.out.println("今天星期⼏都不是");}循环控制语句for循环语句for(初始值,条件表达式,更新)for(int i = 1 ; i <= 10 ; i++){System.out.println(i);}增强for循环for(接收类型的变量,表达式)int [] arrays = {1,2,3,4,5,6,7,8,9,10};for(int i : arrays){System.out.println(arrays);}while循环语句while(条件表达式)int number = 1;while(number <= 100){System.out.println(number);number ++;}do...while循环语句do{先把语句执⾏⼀遍}while(条件表达式);boolean flag = true;do{System.out.println("先执⾏⼀遍");flag = false;}while(flag);break和continue关键字break关键字结束循环的意思;for(int i = 1; i <= 100; i++){if(i == 10){System.out.println("打印10后结束循环");break;}}continue关键字跳过当前循环,进⼊下⼀次循环;for(int i = 1 ; i <= 10; i ++){if(i % 2 == 1){continue;}System.out.println("打印:"+i);}⽅法概述:⽅法就相当于使⽤多⾏代码进⾏组合去实现的⼀个功能⽚段,对代码进⾏封装利⽤,可实现多次调⽤;⽅法的定义修饰符返回值⽅法名称(形参形参名称){⽅法体}public class Function{public static void main(String[] arags){}public void method1(){}public void method2(String name,int age){}public static void method3(){}public int method03(){int a = 3;return a;}public int method04(int a,int b){if(a == b){System.out.println(a + "和" + b + "相等");return -1;}return a > b ? a : b;}}⽅法的重载⽅法的重载是指⽅法名称相同,传递的参数类型不同,个数不同,顺序不同与返回值⽆关;这样的⽅法被称为⽅法的重载;public class Function{public int max(int a,int b) {return a > b ? a : b;}public double max(double a,double b){return a > b ? a : b;}}形参和实参形参是指在()内部的参数,实参是指被真实传递的参数;public class Function{public static vid main(String[] args){Function function = new Function();function.max(3,5);}public int max(int a,int b) {return a > b ? a : b;}}可变参数在⽅法的()中我们有时候不知道要传递多少参数,那么我们可以传递⼀个数据类型紧跟后⾯加上...来表⽰;但需要注意的是⼀个⽅法中指允许⼀个可变参,如果有其他类型的参数,那么可变参数需要写在最后⾯;可变参数本质上就是⼀个数组;public class Function{public void method(String name,int... numbers){for(int num : numbers){System.out.println(num);}}}递归递归的本质就是⾃⼰调⽤⾃⼰,它可以解决⼀些业务,但效率和开销较⼤,对⼀些⽐较⼩的运算可以使⽤;//递归求3的阶乘public class Founction{public static void main(String[] args){}public int founction(int number){int result = 1;if(number == result){return result;}return number * founction(number - 1);}}数组数组就是⼀组数据的集合,Java中的数组必须存储和数据类型相符合的值,不允许与定义的数据类型不匹配;⼀旦数组被创建出来,它的长度就不允许被改变,数组有下标(索引)的概念,都是从0开始,如果操作的数据超过数组的长度那么就会报出下标索引越界异常[ IndexOutofBoundsException ];数组的定义int[] array = new int[3];int array[] = new int[3];int array[] = {1,2,3};数组的内存模型图数组的遍历⽅式int[] arr = new int[10];//⽅式⼀for (int i = 0; i < arr.length ; i ++) {System.out.println(arr[i]);}//⽅式⼆for (int num : arr) {System.out.println(num);}⼆维数组int[][] arr = new int[3][2];String[][] strArr = {{"hello","hello"},{"hi","hi","hi",{"java","java","java","java"}}Arrays⼯具类Arrays数组的⼯具类,是jdk已经帮我们提供好的⼀套数据⼯具类,⽅便我们对数据相关进⾏⼀些操作;int[] arr = {3,51,1,33,82,22,55,53};Arrays.toString(arr);//把数组变成⼀个字符串Arrays.sort(arr);//对数组内容进⾏升序排列Arrays.fill(arr,0);//把数组的内容全部进⾏替换为0常见算法冒泡排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//冒泡排序算法public static void popArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每次⽐较⼀轮,需要减少1次⽐较的次数for (int j = 0; j < arr.length - i - 1; j++) {//如果前⾯的数据⽐后⾯⼤,那么就交换位置if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}选择排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//选择排序public static void selectOrderArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每⽐较⼀次,需要减少1次⽐较的次数,会把⼩的先往前排for(int j = i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}⼆分查找public static int[] arr = new int[]{1, 2, 3 , 4, 6, 7, 8, 13, 19};//2分查找法public static void branchFind(int [] arr,int number){int startNode = 0;int endNode = arr.length-1;int middle = 0;while (startNode <= endNode){//中间的指针由开始节点和结束节点计算得来middle = (startNode+endNode)/2;if(number == arr[middle]){System.out.println("找到了");break;}else if(number < arr[middle]){endNode=middle-1;System.out.println(number+"⼩于中间值,结束节点变更为中间节点-1"); }else if(number > arr[middle]){startNode = middle+1;System.out.println(number+"⼤于中间值,开始节点变更为中间节点+1"); }else{System.out.println("没有找到该元素");break;}}}。
(完整word版)Java学习笔记(必看经典)
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：有什么（属性）：用来描述对象。
能够做什么（方法）：告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数，也可能有返回值。
注意区分：对象（本身）、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象，类是对象的抽象。
其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。
这样才能使每个对象本身做成最好的。
对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。
在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：class Student{代码}注意类名中单词的首字母大写。
实例变量：定义在类中但在任何方法之外。
（New出来的均有初值）局部变量：定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
Java基础课堂笔记
课堂笔记Day 11.java的发展简史1990年末，Sun成立了由James Gosling领导的“Green”计划，为智能家电通用控制系统服务---->C++较复杂，缺少一些性能，工作小组使用的嵌入式平台----->开发新语言Oak---->1994年更名为java---->1995年初发布java--->1996年发布JDK1.0---->1998年发布JDK1.2，正式将java分成了J2SE(java技术的核心和基础，是ME和EE编程的基础)、J2ME（用于控制移动设备和信息家电等有限存储的设备）、J2EE（企业应用开发）---->2002年发布JDK1.4，开源框架开始出现----->2004年发布JDK1.5，JavaSE,JavaME,javaEE---->2006年发布JDK1.6---->2009年，Oracle收购Sun 公司2.JDK、JRE、JVM分别是什么JDK：Java SE Development Kit，Java标准版开发包JRE：Java Runtime Environment,Java运行时环境JVM：运行Java程序的虚拟机3.环境变量的配置，为什么要配置编译和运行Java程序有两个步骤：将源文件编译成字节码，解释执行平台无关的字节码程序。
Windows操作系统根据Path环境变量来查找命令。
4.1)java文件名必须和public修饰的类名相同(2)一个文件可以同时包含多个类，但是只能有一个public修饰的类，并且编译后会分别生成相互独立的类（.class字节码文件）5.(1)标识符:以字母、下划线、美元符号“＄”、人民币符号“￥”开始，由数字、字母、下划线及美元符号组成，不能把关键字或者保留字作为标示符(2)类／接口：使用名词，且每个单词首字母大写，定义实体类要加注释例： public class HelloWorld｛｝(3)方法：使用名词，首字母小写，以后每个单词首字母大写,定义规则：见名思义例:public void findStudentByName()｛｝(4)变量：使用名词，首字母小写，以后每个单词首字母大写，避免使用$例：String studentAdress；(5)包名：全部小写，一般使用本公司/组织网站域名的逆序例：package com.sun.java;(6)注释：单行注释// ctrl+/ ctrl+/多行注释/* */ shift+ctrl+/ shift+ctrl+\文档注释/** */ （通过javac命令生成：-d<directory>:该选项指定一个路径，用于将生成的API文档放到指定目录下-windowtitle<text>:该选项指定一个字符创，用于设置API文档的浏览器窗口标题常用的javadoc标记：@author:指定Java程序的作者@version:指定源文件的版本@param:方法的参数说明信息@return：方法的返回值说明信息@exception:抛出异常的类型）6.( 1)基本数据类型 byte(字节)：1个字节，占8位char(字符): 2个字节，占16位//必须加上单引号-----------（整型）-----------short(短整型)：2个字节，占16位int(整型)：4个字节，占32位long(长整型)：8个字节，占64位//定义long类型的数据，必须在数据后面加上l或者L------------（浮点型）---------float(单精度浮点型): 4个字节，32位//定义float类型数据，必须在数据后面加上F或fdouble(双精度浮点型)：8个字节，64位-----------布尔型--------------boolean：1个字节，只有两种值，true false(2)引用数据类型类（String）、枚举、数组、注解、接口7.数据类型转换 (1)自动类型转换（低精度能自动转换成高精度）当两个类型可兼容，并且目标类型长度大于原类型长度时，可自动转换 byte-> short-> int-> long-> float-> double(2)强制类型转换 int a = (int) 4.562;Day 21.运算符：(1)算数运算符：+，-，*，/,%两数相运算，最终的结果以高字节为主(2)赋值运算符：=,+=,-=,*=,/=,%=i+=3;等同于i=i+3;区别：例:(a)short i=3;i+=2;(b)short j=3;j=j+2;(a)正确，数据类型自动变成short；(b)错误，2默认是int类型，两数相加结果为int，和也为int,与接收方不匹配(3)位(二进制):&,^,|,<<,>>,>>>操作步骤：十进制--->二进制---->运算---->二进制---->十进制&：两者为真，结果为真0&0 00&1 01&0 01&1 1^：相同为0，不同为10^0 00^1 11^0 11^1 0|：一者为真，结果为真0|0 00|1 11|0 11|1 1<<:将运算数的二进制码整体左移指定位数，空出的位置用0填充>>:将运算数的二进制码整体右移指定位数，空出的位置用原来的符号填充//正数符号位：0//负数符号位:1>>>:将运算数的二进制码整体右移指定位数，空出的位置用0填充(4)比较运算符：>,<,>=,<=,==(5)逻辑运算符:&,&&,|,||,^a.T&F和T&&F运算一致b.F&T和F&&T运算不一致：(2>3)&(4>1) 两个表达式均执行，最终结果为false;(2>3)&&(4>1)当第一个表达式执行值为false时，第二个表达式就不执行了，最终结果也为false(6)a++和++a:就近原则：int a=1,x;(1)x=++a;因为++靠近=，所以先执行x=a+1=1+1=2;然后a=a+1=2;(2)x=a++;因为a靠近=，所以先执行x=a=1;然后a=a+1=2;三目运算符（条件运算符）：数据类型变量= (表达式)?值1 ：值2表达式的值为true，值1赋值给变量；表达式的值为false，值2赋值给变量例：int m=(3>4)?1:0;因为3>4为真，所以m=1Day 31.break,continue,returnbreak:完全结束一个循环，跳出循环体continue:终止本次循环，接着开始下一次循环return:结束一个方法例:for(int i=0;i<6;i++){if(i==4){//break; 输出0,1,2,3//continue;输出0,1,2,3,5return;输出0,1,2,3，然后结束for所在的方法}System.out.println("i="+i);}2.数组Java中的数组Array，其包含两个部分，分别是数组的引用和数组的空间两部分。
课堂笔记学习JAVA
public class Hello{public static void main(S tring args[]){System.out. println("你好，很高兴学习Java");}}保存为Hello.java(注意保存的名字必须是和主类的名字一样(包括大小写),所谓主类就是包含main方法的类)(b).按住"窗口+R"组合键打开运行窗口输入cmd进入dos界面转换盘符到刚刚java文件保存路径(例如保存在D盘,输入D:回车)然有执行命令javac Hello.java回车.这时会发现在和Hello.java同一个文件夹下生成了Hello.class字节码文件,因为上面是一个应用程序的格式所以可以通过java解释器来生成应用程序.继续输入java Hello回车.屏幕会显示"你好，很高兴学习Java"b.小应用程序(a)打开记事本输入程序代码:import java.applet.*;import java.awt.*;public class Boy extends Apple t//entends代表Boy继承了小应用程序Applet类{public void paint(Graphics g){g.setColor(Color. red);g.drawString("我一边喝着咖啡，一边学Java呢",5,30);g.setColor(Colo r.blue);g.drawString("我学得很认真",10,50);逻辑类型:boolean用ture(真)和false(假)来赋值,没有赋值默认情况时表示false整数类型:(1)int型变量,内存分配4个字节的空间,即32位的空间,所以可以表示-2^31到2^31-1的整数,例如int x=10;(2)byte型变量,内存分配1个字节的空间,范围从-2^7到2^7-1,例如byte x=127(3)short型变量,内存分配2个字节的空间,范围从-2^15到2^15-1,例如short x=1000(4)long型变量,内存分配8个字节的空间,范围从-2^63到2^63-1,例如long x=700000;字符类型:(1)常量:java使用unicode字符集,所以字符表中的每个字符都是一个字符常量,用单引号括上,例如'A','你','あ'注意有些字符不能通过键盘直接输入到字符串中或程序中,这时就需要转意字符常量,例如: '\n'(换行),'\b'(退格),'\''(单引号)等等.(2)变量:通过关键字char来定义字符变量char型变量,内存分配2个字节的空间,因为是字符不存在负数的概念,所以范围从0到2^16-1(即65535),例如char name='刘',grade='A'如果要查一个字符在unicode字符集里的顺序位置,必须使用int类型转换,如(int) 'A',但不可以用short型转换(范围只有一半);同样道理如果想得到一个在0到655 35之间的数字在unicode字符集中所对应的字符必须使用char型转换,如(char)30 000.具体含义理解如下面代码程序代码:public class Sign_Num{public static void main(String args[]){char chinaWord='你',japanWord='ぁ';int p1=36328,p2=38358;System.out.println("汉字\'你\'在unicode表中的顺序位置:"+(int)china Word);System.out.println("日语\'ぁ\'在unicode表中的顺序位置:"+(int)japan Word);System.out.println("unicode表中第20328位置上的字符是:"+(char)p1);System.out.println("unicode表中第12358位置上的字符是:"+(char)p2);}}除了char以外还要稍微介绍一下String,在C或C++中,String是一个以空为终结的字符数组,而在java中它是ng包中的String类来创建一个字符串变量,因此字符串变量是一个对象.String的具体介绍在后面会学习到.浮点类型:(1)float型内存分配4个字节,占32位,范围从10^-38到10^38和-10^38到-10^-38例float x=123.456f,y=2e20f;注意float型定义的数据末尾必须有"f",为了和double区别(2)double型内存分配8个字节,范围从10^-308到10^308和-10^-308到-10^-308例double x=1234567.98,y=8980.09d;末尾可以有"d"也可以不写基本数据类型转换:类型按精度从低到高:byte short int long float double(1)当把级别低的变量赋值给级别高的变量时,系统自动完成数据类型的转换,例int x=100;float y;y=x;结果y的值应该是100.0(2)当把级别高的变量赋值给级别低的变量时,必须使用显示类型转换运算,格式为:(类型名)要转换的值;例int x=(int)23.89f;结果x的值为23所以强制转换运算可能导致精度的损失(3)当把一个整数赋值给一个byte,short,int或long型变量时,不可以超出这些变量的取值范围,否则必须进行类型转换运算,例byte a=(byte)128;byte b=(byte)-129;//超出范围结果a值为128,b值为127用下面的代码来复习下:程序代码:public class Example2_2{public static void main(String args[]){int c=2200;总结:本节课把编程语言中的基础-关键字,数据类型等概念复习一遍,尤其是在java中的用法,为以后在使用变量的学习中做基础.return distance;}void g(){inty;y=a;//非法,a是局部变量,不在find()中就会失效}}注意:成员变量在它在类中书写的先后位置无关.但不提倡把成员变量的定义分散的写在方法之间或类体的后面.b.成员变量又分为实例成员变量(实例变量)和类成员变量(类变量)类变量是指变量类型前加关键字static的成员变量,也称为静态变量.例:程序代码:class Sun{float x;//实例变量static int y;//类变量}c.当局部变量与成员变量名字相同时,则成员变量被隐藏,即这个成员变量在这个方法内暂时失效,例:程序代码:class Tom{int x=90,y;void f(){int x=3;y=x;//y得到的值应是3,因为成员变量x=90与y在此方法体里失效}}但如果想在方法体内使用成员变量则通过关键字this来实现,例:程序代码:class三角形{float sideA,sideB,sideC,lengthSum;void setside(float sideA,float sideB,float sideC)载的.用法:一般用类创建对象时,使用构在方法,后面会有详细说明.程序代码:class梯形{float上底,下底,高;梯形(){上底=60;下底=100;高=20}梯形(float x,float y,float z){上底=x;下底=y;高=z;}}2.对象类是创建对象的模板.当使用一个类创建了一个对象时,也就是说给出了这个类的一个实例.(1)对象的创建:包括对象的声明和为对象分配内存空间声明格式:类的名字对象的名字;分配内存空间格式;类的名字对象的名字=new类的名字();例:程序代码:class XiyoujiRenwu{float height,weight;String head,ear,hand,foot,mouth;void speak(String s){System.out.println(s);}}class A{public static void main(String args[]){XiyoujiRenwu zhubajie;//声明对象zhubajie=new XiyoujiRenwu();//为对象分配内存，使用new运算符和默认的构造方法class XiyoujiRenwu{float height,weight;String head,ear,hand,foot,mouth;void speak(String s){head="歪着头";System.out.println(s);}}class Example4_3{public static void main(String args[]){XiyoujiRenwu zhubajie,sunwukong;//声明对象zhubajie=new XiyoujiRenwu();//为对象分配内存sunwukong=new XiyoujiRenwu();zhubajie.height=1.80f;//对象给自己的变量赋值zhubajie.head="大头";zhubajie.ear="一双大耳朵";sunwukong.height=1.62f;//对象给自己的变量赋值sunwukong.weight=1000f;sunwukong.head="绣发飘飘";System.out.println("zhubajie的身高："+zhubajie.height);System.out.println("zhubajie的头："+zhubajie.head);System.out.println("sunwukong的重量："+sunwukong.weight);System.out.println("sunwukong的头："+sunwukong.head);zhubajie.speak("俺老猪我想娶媳妇");//对象调用方法System.out.println("zhubajie现在的头："+zhubajie.head);sunwukong.speak("老孙我重1000斤，我想骗八戒背我");//对象调用方法System.out.println("sunwukong现在的头："+sunwukong.head);}}程序代码:class梯形{float上底,下底,高,面积;梯形(float x,float y,float h){上底=x;下底=y;高=h;}float计算面积(){面积=(上底+下底)*高/2.0f;return面积;程序代码:class Takecare{static int x;int y;}class A{Takecare A1=now Takecare();Takecare A2=now Takecare();//在此代码中如果给x赋值那么,A1.x和A2.x指的是同一个内存空间,无论那个对象修改都是对一个x进行操作}当java程序执行时,类的字节码文件被加载到内存,如果该类没有创建对象,类的实例成员变量不会被分配内存.但是类中的类变量被加载到内存时,会被分配相应的内存空间.简单的说就是,没创建对象当类加载到内存时候,只有类变量(static)会被分配内存空间,只有创建对象时候实例变量才会被分配空间的.像上面的例子里,在没有创建Takecare的对象时候,Takecare::x是有空间的即此时可以访问的,当且仅当Takecare A1=now Takecare()时A1.y才会有内存空间.通过下面的例子体会一下,不同的对象会共享一个底程序代码:class梯形{float上底,高;static float下底;梯形(float x,float y,float h){上底=x;下底=y;高=h;}float获取下底(){return下底;}void修改下底(float b){下底=b;}}class Example4_7{public static void main(String args[]){梯形laderOne=new梯形(3.0f,10.0f,20),laderTwo=new梯形(2.0f,3.0f,10);梯形.下底=200;//通过类名操作类变量System.out.println("laderOne的下底:"+laderOne.获取下底());System.out.println("laderTwo的下底:"+laderTwo.获取下底());laderTwo.修改下底(60);//通过对象操作类变量System.out.println("laderOne的下底:"+laderOne.获取下底());System.out.println("laderTwo的下底:"+laderTwo.获取下底());}}2.实例方法和类方法和实例变量和类变量的描述时是一样,当类的字节码加载到内存是类方法的入口地址就会被加载到相应的内存空间,即此时可以访问;而当且只有创建对象之后,实例方法的入口地址才会被加载到内存中,这是才可以调用.既然知道了实例方法和类方法开始生效的时间,可以知道他们可以调用何种类的成员变量:1)类方法因为是在创建对象之前就已经生效了,这时候实例变量还没有被分配内存空间,只有类变量被分配了内存空间,所以类方法只能调用被分配内存空间的变量即类变量;2)实例方法是在创建对象之后才开始生效的,这是无论是类变量还是实例变量都已经被分配了内存空间,所以实例方法生效后可以调用类变量和实例变量.程序代码:class Fibi{public static long fibinacii(int n){long c=0;if(n==1||n==2)c=1;elsec=fibinacii(n-1)+fibinacii(n-2);return c;}}public class Example4_8{public static void main(String args[]){System.out.println(Fibi.fibinacii(7));//可见还没哟创建Fibi的对象时就可以调用fibinacii()方法,因为属于static修饰的类变量}}包包是java中有效的管理类的一个机制,包有类似于目录结构的层次结构.通过import关键字可以在程序中使用包语法格式:import<包名>.*;//包含包中的所有类import<包名><类名>//包含包中的指定类例如:import java.awt.*;//包含java.awt包中的所有类import java.awt.JButton;//包含java.awt包中的JButton类既然知道了怎么使用,那如何制作包呢,可以通过关键字package声明包语句.package语句作为java源文件的一个条语句,指明该源文件定义的类的所在包.语法格式:package包名;如果源文件中省略了package语句,那么源文件中定义命名的类将被隐含的认为是无名包的一部分,即源文件中定义命名的类在同一个包中,但该报没有名字而已.包还可以是一个合法的表示符,也可以是若干个标识符加"."分割而成,如package sunrise;package 程序如果使用了包的语句,如package desney.tom;那么目录必须包含有如下结构,如C:\cartoon\desney\tom并且要将源文件保存在目录C:\cartoon\desney\tom中,才能使用这个包,然后编译源文件: C:\cartoon\desney\tom\javac源文件.java或jacac C:\cartoon\desney\tom\源文件.java从一个例子体会此过程:程序代码:package desney.tom;public class PrimNumber{public void getPrimnumber(int n){int sum=0,i,j;for(i=1;i<=n;i++){for(j=2;j<=i/2;j++){if(i%j==0)break;}if(j>i/2)System.out.print(""+i);}}public static void main(String args[]){PrimNumber p=new PrimNumber();p.getPrimnumber(20);}}保存上述源文件到C:\cartoon\desney\tom下,然后编译C:\cartoon\desney\tom\javac PrimNumber.java运行程序时必须到desney\tom的上一层目录cartoon中来运行,如C:\cartoon\java desney.tom.PrimNumber因为起了报名,类PrimNumber的全名应该为desney.tom.PrimNumber导入这个包时也要注意名称程序代码:import desney.tom.PrimNumber;所以用package可以把认可类都打包然后在其他程序中使用,于c或c++中的头文件有着相似的效果,差别就是java中的包里只能是类注意:使用import可以导入包中的类.在编写源文件时,除了自己编写的类外,经常需要使用java提供的去多类,这些类可能不在一个包中.在学习java时,使用已经存在的类,避免一切从头做起,这是面向对象编程的一个重要方面.总结:具体的把static修饰的变量和方法的使用方法做了介绍;对java中包有了初步认识。
java基础知识点笔记
java基础知识点笔记Java是一门广泛应用于跨平台开发的高级编程语言。
作为一名Java开发人员，掌握Java基础知识点是非常重要的。
本文将介绍Java 基础知识点的笔记，帮助您更好地掌握Java语言。
1. 数据类型Java支持的基本数据类型有8种，分别是byte、short、int、long、float、double、char和boolean。
其中，byte、short、int、long、float、double是数字类型，char是字符类型，boolean是布尔类型。
2. 变量在Java中，变量是用于存储数据值的容器。
声明一个变量需要指定变量的数据类型和变量名字。
变量名字必须是唯一的，并且遵循标识符规则。
3. 运算符Java支持的运算符包括算术运算符、关系运算符、逻辑运算符等。
算术运算符包括加、减、乘、除、取模等。
关系运算符用于比较两个值是否相等，逻辑运算符用于连接两个或多个条件。
4. 控制语句Java中的控制语句包括条件语句、循环语句和分支语句。
条件语句根据条件的真假分别执行不同的代码块。
循环语句用于重复执行一段代码块，分支语句用于根据条件选择不同的执行路径。
5. 数组数组是一组具有相同数据类型的变量的集合。
Java中的数组可以是一维或多维的。
在Java中，数组的下标从0开始。
6. 类和对象Java是面向对象的语言，一个类是一个对象的蓝图，对象是类的一个实例。
类包含属性和方法，属性是类的状态，方法是类的行为。
7. 方法方法是一段代码块，它包含一组语句，用于执行特定的任务。
方法具有返回值和参数。
在Java中，所有的方法都是类的成员。
8. 继承继承是一种面向对象的编程技术，它允许一个类继承另一个类的属性和方法。
继承可以提高代码的复用性，减少代码的重复。
9. 接口接口是一种抽象的数据类型，它定义了一组方法的声明，但没有实现。
接口可以被类实现，一个类可以实现多个接口。
10. 异常处理异常是程序执行过程中的一种错误，它会导致程序中断。
java基础知识点笔记
java基础知识点笔记Java是一种面向对象的编程语言，其广泛应用于大型企业级应用程序开发和 Android 应用程序开发。
在学习 Java 的过程中，需要掌握一些基础知识点，下面是一些关键的笔记：1. Java 的特点Java 是一种跨平台的编程语言，因为它可以在不同的操作系统和硬件平台上运行。
此外，Java 具有强类型和静态类型的特点，代码安全性高，易于维护和扩展。
2. Java 的基本数据类型Java 的基本数据类型包括 boolean、byte、char、short、int、long、float 和 double 八种类型。
其中，boolean 类型表示 true 或false 的布尔值，而其他类型则表示不同的数字类型。
3. Java 的运算符Java 的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符和赋值运算符。
这些运算符可以用于执行各种数学和逻辑操作，例如加、减、乘、除、比较、逻辑与或非等操作。
4. Java 的控制语句Java 的控制语句包括条件语句和循环语句。
条件语句通过 if或 switch 关键字实现，用于根据条件执行不同的代码分支。
循环语句通过 for、while 或 do-while 关键字实现，用于重复执行一段代码块。
5. Java 的数组Java 的数组是一种存储相同类型数据的数据结构，可以通过下标访问其中的元素。
Java 中的数组可以是一维数组或多维数组，可以通过 new 关键字来创建。
6. Java 的面向对象编程Java 是一种面向对象的编程语言，支持封装、继承和多态等面向对象编程特性。
在 Java 中，类是构建对象的基本单位，可以通过定义类来封装数据和行为，而对象是类的实例。
7. Java 的异常处理Java 的异常处理机制可以用于处理程序在运行过程中可能出现的异常情况，例如除零、数组越界等。
在 Java 中，异常通过try-catch 块来捕获和处理，可以提高程序的健壮性和可靠性。
java课堂笔记(全部基础知识)
Java_U1课堂笔记（一）初识Java一、配置Java环境变量：1、复制JDK安装路径，如：C:\Program Files (x86)\Java\jdk1.7.0_51\bin2、粘贴到我的电脑->属性->高级系统设置->环境变量->Path3、加上英文的分号4、验证是否配置正确：dos-->java -version进入DOS窗口的方法：运行（或快捷键windows键+r）二、Java程序编写三步骤：编写 .java编译：javac **.java运行java **三、使用jad反编译工具：DOS中切换至jad安装目录，如：C:\jad1.5.8g.win输入命令：jad -s java D:\t01\HelloWorld.class四、变量的使用:页脚内容1变量取名，命名规则类型数值：int、double、float(f)非数值:char、String类型名字= 值;int age=10;五、上机验证：System.out.println(5+3);System.out.println("5"+3);六、Scanner的使用，接收用户键盘输入Scannerimport java.util.Scanner;Scanner input=new Scanner(System.in);input.next();（相关方法，nextDouble()、nextFloat()、nextInt(等）bin:exejre页脚内容2libsrc.zip（二）数据类型一、数据类型转换自动类型转换：int num=100;double b=num;强制类型转换double num=100.9;int b=(int)num;二、运算符赋值运算符=算数运算符+ - * / % ++ --+= -= *= /= %=关系运算符> < >= <= == !=逻辑运算符&& || ！页脚内容3条件运算符？：了解优先级即可三、流程控制1、if:基本ifif-else多重if嵌套if注意：条件是boolean值常见错误：if(num=5){}else{}大括号不省略多重if顺序问题注意：页脚内容4流程图的使用和问题的分析解决过程2、switch等值比较注意：（1）语法上的常见错误（2）和多重if的异同循环结构：解决重复性的操作简介高效（三）循环结构一：循环：(1)while循环while(条件){操作循环变量迭代}注意：页脚内容5代码缩进循环能否正常退出（2）do-while循环do{循环}while(条件);注意：代码缩进循环能否正常退出和while的区别：语法上、执行上（至少执行一次）（3）for循环for(变量初始化;条件;变量迭代){循环操作}页脚内容6注意：代码缩进循环能否正常退出执行顺序循环变量可以有多个二、双重循环双重循环的特点：外层循环进入一次，内层循环就要完整的执行一遍特点：外执行一次内执行一轮双重循环次数：外层循环次数*内层循环的次数实现的重点：页脚内容7（1）确定谁做外层循环，确定谁做内层循环（2）两层循环变量有没有规律性的关系1、打印图形：找规律矩形行i外层星星j内层1 52 53 54 55 5平行四边形行i外层内层：空格星星1 4=5-i 52 3=5-i 53 2=5-i 5页脚内容84 1=5-i 55 0=5-i 5等腰三角形行i外层内层：空格星星1 4=5-i 1=2*i-12 3=5-i 3=2*i-13 2=5-i 5=2*i-14 1=5-i 7=2*i-15 0=5-i 9=2*i-12、打印九九乘法表行i（1-9）第一个操作数i 第二个操作数（从1到i）三：循环应用1、分析需求：重复做一件事情前提条件（循环进入的条件）做什么事情（循环操作）页脚内容92、用代码解释选择一种合适的循环结构whiledo-whilefor根据所选择的结构套用语法while(条件){}do{}while(条件);for(循环变量初始化;条件;迭代){}3、容易出错的点（1）变量在何处声明例1：计算5门课平均成绩页脚内容10例2：for(int i=0;i<=6;i++){System.out.println(i);}int j=i;System.out.println(j);（2）没有适当的（合适的）跳出循环根本跳不出来根本进不去循环多或少循环了一次四、循环的跳转break:跳出整个循环continue：跳出本次循环，进入下次循环return:结束方法（了解即可）五、程序调试页脚内容11设置断点Debug->单步运行F5 F6观察变量（三）数组一、数组1、数组的基本使用（1）数组的作用一组相同数据类型的数数组也是变量，内存中一串连续的空间（2）数组的几个基本概念标识符（数组名字）元素下标：从0开始数据类型数组的长度（数组名字.length）（3）数组使用步骤声明数组页脚内容12int[] num;int num[];分配空间num=new int[8];赋值处理数据int[] num={5,8,7};int[] num=new int[]{5,8,7};（4）循环和数组结合的使用下标（0-数组.length-1）遍历时两种方法：方法一：传统for方法二：//增强型for(foreach)for(int score:scores){sum+=score;页脚内容13}二、回顾数组变量，内存中一串连续的空间相同数据类型的一组数据数组的基本概念元素数据类型（数组类型）下标（0，数组.length-1）数组的长度：数组.length数组的基本使用声明数组（类型[] 数组名称或类型数组名称[]）分配空间（数组名称= new 数据类型[5];）赋值（num[0]= ;）处理数据变量：基本数据类型页脚内容14int、double、float、char、boolean引用数据类型String、数组内存分布不同使用上不同.三、数组的典型使用1、求最大值、最小值（打擂台）2、插入算法（找位置）3、冒泡排序数组存储5个数字下标：0 1 2 3 4外层循环内层循环i:0第一轮+ j比较次数：4 =4:length-1页脚内容15i:1第二轮+ j比较次数：3=4:length-1i:2第三轮+ j比较次数：2 =4:length-1i:3第四轮+ j比较次数：1=4:length-1i+j=数组.length-1j=数组.length-1-i共比较几次？5个数字：4+3+2+1=106个数字：5+4+3+2+1=157个数字：6+5+4+3+2+1=21n个数字：（n-1）+(n-2)+(n-3)+.....+1=n*(n-1)/24、Arrays类的使用常用方法：页脚内容16sort().....记得查API帮助文档（帮助文档已经在网盘中提供了，如果大家在Oracle官网中没有下载，可以找中心的技术顾问老师提供网盘用户名和密码，登录后拿到帮助文档）数据类型基本数据类型int double char boolean 。
Java基础笔记狂神说版
Java基础笔记狂神说版Java基础学习笔记（狂神说版）三、Java⽅法（⼀）⽅法的重载1. 重载的概念：重载就是在⼀个类中，有相同的函数名称，形参不同的函数。
2. ⽅法重载的规则：（1）⽅法名必须相同（2）参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）（3）⽅法的返回类型可以相同，也可以不同（4）仅仅返回类型不同不⾜以成为⽅法的重载3. 实现理论:⽅法名称相同时，编译器会根据调⽤⽅法的参数个数，参数类型去逐个匹配，以选择对应的⽅法，如果匹配失败，则编译器报错（⼆）⽅法的可变参数可变参数（不定项参数）：JDK1.5开始，Java⽀持传递同类型的可变参数给⼀个⽅法在⽅法声明中，在指定参数类型中加⼀个省略号（...）⼀个⽅法中只能指定⼀个可变参数，他必须是⽅法的最后⼀个参数，普通参数声明必须在其之前（三）⽅法的递归递归就是：A⽅法调⽤A⽅法！就是⾃⼰调⽤⾃⼰递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，⼤⼤减少了程序的代码量。
递归的能⼒在于⽤有限的语句定义对的⽆限集合。
递归结构包括两个部分：（1）递归头：什么时候不调⽤⾃⾝⽅法。
如果没有头，将陷⼊死循环。
（2）递归体：什么时候需要调⽤⾃⾝⽅法。
四、Java数组（⼀）数组的概念数组的定义：数组是相同类型数据的有序集合。
数组描述的是相同类型的若⼲个数据，按照⼀定的先后次序排列组合⽽成。
其中，每⼀个数据称作⼀个数组元素，每个数组元素可以通过⼀个下标来访问他们。
数组的四个基本特点：（1）其长度是确定的。
数组⼀旦被创建，它的⼤⼩就是不可以被改变的。
（2）其元素必须是相同类型，不允许出现混合类型。
（3）数组中的元素可以是任何数据类型，包括基本类型和引⽤类型。
（4）数组变量属引⽤类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本⾝就是对象，Java中对象是在堆中的，因此数组⽆论保存原始类型还是其他对象类型，数组对象本⾝是在堆中的。
JAVA学习完整版详细笔记
Java基础知识总结Java基础知识总结写代码：1，明确需求。
我要做什么？2，分析思路。
我要怎么做？1,2,3。
3，确定步骤。
每一个思路部分用到哪些语句，方法，和对象。
4，代码实现。
用具体的java语言代码把思路体现出来。
学习新技术的四点：1，该技术是什么？2，该技术有什么特点(使用注意)：3，该技术怎么使用。
demo4，该技术什么时候用？test。
-----------------------------------------------------------------------------------------------一：java概述：1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言更名为Java；Java的三种技术架构:JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。
2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。
3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。
环境变量的配置：1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdkpath=%JAVA_HOME%\bin2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。
Java基础知识笔记（含代码举例）
Java基础知识笔记（含代码举例）⽂章同步：知乎:简书：博客园：⼀、注释、标识符、关键字注释平时我们写的代码量较⼩时，可以看的懂。
但是⼀旦结构复杂起来，我们就需要注释了注释平不会被执⾏，是给我们程序员看的书写注释是⼀个⾮常好的习惯java中有三种注释：单⾏注释 // 注释部分多⾏注释 /* 注释部分*/⽂档注释//有趣的代码注释：/*_(\_/),((((^`\(((( (6 \,((((( , \,,,_ ,((((( /"._ ,`,((((\\ ,... ,(((( / `-.-'))) ;' `"'"'""(((( (((( / ((( \)) | |(( | . ' |)) \ _ ' `t ,.')( | y;- -,-""'"-.\ \/) / ./ ) / `\ \|./ ( ( / /'|| \\ //'||| \\ _//'|||| )) |_/ ||\_\ |_/ ||`'" \_\`'"*/关键字abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
Java基础学习笔记资料
(一)Java编程基础1.Java语言的跨平台是通过针对不同的操作系统，提供不同的jvm来保证的。
2.JDK,JRE,JVM的作用及关系1)作用JVM：保证Java语言跨平台JRE：Java程序的运行环境JDK：Java程序的开发环境2)关系JDK：JRE+工具JRE：JVM+类库3.为了使程序能够独立运行，必须定义main方法main方法是程序的入口被jvm自动调用4.原码，反码，补码正数的原，反，补码都相同负数的反码为原码符号位不变，按位取反负数的补码为原码符号位不变，按位取反，末位加一5.关键字1)被Java语言赋予特定含义的单词2)特点：全部小写。
3)注意事项：A：goto和const作为保留字存在。
B：类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记6.标识符1)就是给类，接口，方法，变量等起名字的字符序列2)组成规则：A：英文大小写字母B：数字C：$和_3)注意事项：A：不能以数字开头B：不能是java中的关键字C：Java语言严格区分大小写7.常见的命名规则(见名知意)：username，password等A：包名全部小写单级包：小写举例：cn,com多级包：小写，并用.隔开举例：com.baidu，com.renrenB：类名或者接口一个单词：首字母大写举例：Student,Demo多个单词：每个单词首字母大写举例：HelloWorld,StudentNameC：方法或者变量一个单词：首字母小写举例：name,main多个单词：从第二个单词开始，每个单词首字母大写举例：studentAge,showAllNames()D：常量全部大写一个单词：大写举例：PI多个单词：大写，并用_隔开举例：STUDENT_MAX_AGE8.注释1)就是对程序进行解释说明的文字2)分类：A：单行注释// 注释内容B：多行注释/* 注释内容 */C：文档注释/** 注释内容 */D：单行注释可以嵌套使用，但是多行注释不可以嵌套使用9.常量1)在程序执行的过程中，其值不发生改变的量2)分类：A：字面值常量B：自定义常量3)字面值常量A：字符串常量 "hello"B：整数常量12,23C：小数常量12.345D：字符常量'a','A','0'E：布尔常量true,falseF：空常量null4)在Java中针对整数常量提供了四种表现形式A：二进制由0，1组成。
JAVA基础知识笔记大全
石材背景墙组装电脑3000元电脑配置单Java编程基础说明1.1. Java开发环境搭建JDK与JREJDK(J ava D evelopment K it) Java开发工具，包含开发Java程序的所有组件，包含JRE JRE(J ava R untime E nvironment) Java运行环境，如果要运行Java程序，就需要JRE的支持常用组件:src.zip Java是一门开源的语言，其源代码都在这个压缩包中rt.jar Java的基础核心类库，我们编写Java程序时使用的class都在这个jar包中javac.exe 编译器，将.java源代码编译为.class文件java.exe 虚拟机，运行Java程序的工具jar.exe 将class文件打成jar包的工具javadoc.exe 生成帮助文档的工具环境变量:环境变量是指在操作系统中用来指定操作系统运行环境的一些参数JA V A_HOME:在环境变量中新建JA V A_HOME指定到jdk的安装目录，有些java的安装软件运行会寻找JA V A_HOMEpath：如果想在任意目录下运行一个程序，我们就需要将程序所在的路径配置在path环境变量中。
通常我们会将javac.exe所在目录配置到path中，因为我们需要在任意目录下都能编译Java源文件。
配置完成之后可以在命令行输入javac测试，如果显式帮助信息则是配置成功。
配置：%JA V A_HOME%\bin;classpath：Java虚拟机运行时加载类的路径。
JDK5之后不配置默认为当前目录“.”。
如使用JDK1.4或以下版本时需要人工配置。
暂时不需要配置，默认加载当前目录下的所有class文件。
配置方式：我的电脑鼠标右键点击我的电脑–属性–高级–环境变量找到要修改的变量将其值修改，此种方式永久有效注意配置后检查：编译器版本查看方式：javac –version虚拟机版本查看方式：java –version1.2. HelloWorld编写源代码在电脑磁盘中新建记事本HelloWorld.txt，更改扩展名改为.java，使用记事本在java文件中写入代码。
java课堂笔记
# Java课堂笔记## 1. Java简介- Java是一种高级编程语言，由Sun Microsystems于1995年发布。
- Java具有跨平台特性，可以在不同的操作系统上运行。
- Java采用面向对象的编程范式，具有丰富的类库和强大的功能。
## 2. Java开发环境搭建- 下载安装Java Development Kit（JDK），包括Java编译器和运行时环境。
- 配置环境变量，将JDK的安装路径添加到系统的PATH变量中。
- 安装集成开发环境（IDE），如Eclipse、IntelliJ IDEA等，以提供编写、调试和管理Java代码的功能。
## 3. Java基本语法- 类和对象：Java通过类来定义对象的属性和行为。
- 变量和数据类型：Java支持多种数据类型，包括整型、浮点型、字符型、布尔型等。
- 控制语句：Java提供了条件语句（if-else、switch）、循环语句（for、while、do-while）等控制结构。
- 方法和函数：Java中的方法用于封装可重复使用的代码块，实现代码模块化和提高代码复用性。
- 异常处理：Java提供了异常处理机制，可以捕获和处理程序中的异常情况。
## 4. 面向对象编程- 封装：将数据和操作封装到一个对象中，通过访问控制符限制对对象的访问。
- 继承：通过继承机制，子类可以继承父类的属性和方法，并可以重写或添加新的方法。
- 多态：同一种类型的对象，在不同的情况下可以表现出不同的行为。
- 接口：接口定义了一组方法的集合，用于规范类的行为。
## 5. Java类库- Java类库提供了大量的API（应用程序编程接口），包括输入输出、网络通信、图形界面、数据库操作等功能模块。
- 常用的类库包括ng、java.util、java.io、等。
- 通过引入相应的包（import语句），可以在代码中使用Java类库提供的类和方法。
以上是关于Java课堂的笔记概要，涵盖了Java的基本语法和面向对象编程的相关内容。
java 基础笔记
Java 是一种广泛使用的编程语言，具有丰富的特性和强大的功能。
以下是一些Java 基础知识的笔记：基本语法：Java 是一种面向对象的编程语言，使用类和对象的概念。
基本的语法包括变量、数据类型、运算符、控制流语句（如if、for、while 等）和异常处理。
类和对象：类是对象的模板，定义了对象的属性和方法。
对象是类的实例，具有类定义的属性和方法。
Java 中的类通常包含构造函数、属性和方法。
封装：封装是面向对象编程的一个重要特性，它隐藏对象的内部状态并保护对象的状态。
通过将数据和操作数据的代码封装在类中，可以控制对数据的访问和修改。
继承：继承是面向对象编程的另一个重要特性，它允许一个类继承另一个类的属性和方法。
子类可以继承父类的属性和方法，并且可以添加自己的属性和方法。
多态：多态是指一个接口可以有多种实现方式。
在Java 中，多态通过继承和接口实现。
通过使用多态，可以将父类类型的引用指向子类对象，并在运行时确定实际类型。
集合框架：Java 提供了一套丰富的集合框架，用于存储和操作对象集合。
集合框架包括List、Set、Queue 和Map 等接口和实现类。
这些接口提供了丰富的操作集合的方法，如添加、删除、查找等。
输入输出流：Java 提供了一套丰富的输入输出流类，用于处理数据的输入和输出。
输入流用于从文件或网络读取数据，而输出流用于将数据写入文件或网络。
异常处理：Java 提供了一套异常处理机制，用于处理程序中的错误和异常情况。
异常是程序运行时可能出现的问题，如文件找不到、数组越界等。
通过使用try-catch 语句块，可以捕获和处理异常。
泛型：泛型是Java 5 中引入的一个新特性，它允许在编译时指定类、接口或方法的参数类型。
通过使用泛型，可以提高代码的可重用性和安全性。
多线程编程：Java 支持多线程编程，允许多个线程同时执行代码。
通过实现Runnable 或Callable 接口，可以创建线程并控制线程的执行。
Java学习笔记(张平)
Java编程语言基础第一章：初识java（1）相关知识JDK：目录结构（安装到java.home）JVM：管理内存、不同的操作系统需要对应不同版本的JVMJRE：Java程序运行环境的根目录Bin：编译器、解释器、各种工具、存放文件Lib：库文件Demo：演示例子Include：本地方法文件虚拟机：多线程索引定位：已知类和方法Ctrl+alt+↓（复制向下）（2）java技术平台介绍ME：移动端、安卓方向SE：标准版、基础核心、银行软件、安全性高EE：企业版、主要用于互联网程序开发（3）java编码的规范一行一条代码、注意换行和缩进、类名不可用void{}的使用位置，开始的{跟在一行代码的末尾，结束的}另起一行放置（4）编译三步走（写.java 译.calss行）一次编译，随处运行写：记事本编辑，后缀为 .java译：javac HelloWorld.java行：java HelloWorld①反编译方式：javap-c、eclips②格式要求public static void或static public void（三个不能少）String[]args 是数组，可以写成s③输出：计算未声明，就取整④有ln换行输出，无ln不换行（5）3种注释单行：// 多行：/* */ 文档注释：/** */（6）转义符换行：\n 水平制表格：\t【例】“STB\tJAVA” stb+“\t”+java 【变分非合】（7）ascII码表①排序：A对应65，a对应97【大小中文】第二章：变量、数据类型和运算符（1）命名规范①类名：大大（帕斯卡式） HelloWorld②变量：小大大（驼峰式） int myMoney=2000;③常量：final大大_ final int MY_MONEY = 2000;只能被赋值一次，从始至终不变（2）变量命名规则①首字母只能是字母_美元（钱），后面用字母_美元（钱）、数字②不能使用关键字（3）数据类型：【byte short int long、fdcb（1248,482不定 1字节=8bit）】①基本数据类型byte ：字节型 short：短整型 int：整型 long：长整型（整数）float：单精度浮点型（整数、小数） double：双精度浮点型char：字符型单个字符 boolean：布尔类型②引用数据类型：String、数组、用户自定义、接口③Java中所有小数默认为double类型，如需赋值给float变量，后面加f 【例】float f =2.11f或2.11F小数④boolean可以为null⑤数据类型转换自动转换：兼容、目标大于源类型一个操作数为double，其他自动提升为double强制转换：（类型名）表达式，强制转换会丢失数据精度【例】double a = 3.14; int b =(int)a;（4）关系运算符（用来比较运算结果，只能用boolean判断正误）【例】boolean isBig = 5<7; 【含有重新录入、结束、退出，用boolean】（5）条件运算符（三元运算符，可以放在输出代码中）int min = 5<7?5:7;String result = Score >90? “奖励”：“惩罚”（6）自增自减num++即num+1、num--即num-1、num+=2即num=num+2++i（先加后用）、i++（先用后加）（7）取数【除余】int geWei = num%10int shiWei = num/10%10int baiWei = num/100%10int qianWei = num/1000（8）控制台录入【4步：13随机合法、2数组声明分配for】导包：import java.util.Scanner;int random =(int)(Math.random()*10); 产生随机创建对象：Scanner intput =new Scanner (System.in);数组：声明分配 for 提示输入：System.out.println(“”);if (input.hasNextInt()==true) 输入字符是否合法调用： String a= input.next(); 接受Stringint a= input.nextInt(); 接受intdouble a= input.nextDouble(); 接受double（1）结构化程序：顺序结构、循环结构、选择结构（2）if结构的种类①if——简单组合多条if、if、if，可执行多条②if、else——简单组合的分支③if、else if 、else——复杂组合的分支满足一个即退出、从小到大或从大到小④嵌套if（包含if、else）、else（包含if、else）——复杂逻辑判断（1）switch【用于数字】int a =1; 也可放入String类型switch(a){case 1：System.out.println(“”);break; 无break，显示匹配往后case 2：System.out.println(“”);break;Default：default默认在前面和后面，并不影响流程判断System.out.println(“”);break;（1）程序调试①Eclipes和MyEclipse共同特征：设置断点，启动调试②是针对运行有误。
java基础整理笔记超详细
java基础整理笔记超详细Java是一种面向对象的编程语言，具有广泛的应用领域。
下面我将从多个角度对Java基础知识进行整理，以帮助你更好地理解和掌握Java编程。
一、Java基础语法：1. 标识符和关键字，Java中标识符的命名规则和规范，以及常用的关键字。
2. 数据类型，Java的基本数据类型和引用数据类型，以及它们的取值范围和默认值。
3. 变量和常量，如何声明和使用变量，以及常量的定义和使用。
4. 运算符，Java中的算术运算符、赋值运算符、逻辑运算符等，以及它们的优先级和结合性。
5. 控制流程，Java中的条件语句（if-else、switch-case）、循环语句（for、while、do-while）等，以及它们的用法和注意事二、面向对象编程：1. 类和对象，如何定义和使用类，以及如何创建对象和调用对象的方法。
2. 继承和多态，Java中的继承关系和多态特性，以及它们的作用和使用方法。
3. 封装和抽象，如何使用访问修饰符实现封装，以及如何使用抽象类和接口实现抽象。
4. 方法重载和方法重写，方法重载和方法重写的区别和使用场景。
5. 异常处理，Java中的异常分类，以及如何使用try-catch-finally块处理异常。
三、Java常用类库：1. 字符串处理，String类的常用方法，以及正则表达式的使2. 集合框架，Java中的集合类（List、Set、Map）的特点和用法，以及常用的集合操作。
3. 输入输出，Java中的输入输出流（字节流、字符流）的使用方法。
4. 文件操作，如何读写文件，以及文件路径的处理。
5. 时间日期，Java中的日期和时间处理类（Date、Calendar、SimpleDateFormat）的使用方法。
四、常用开发工具和技术：1. 开发环境搭建，如何安装和配置Java开发环境（JDK、IDE 等）。
2. 调试技巧，如何使用调试器进行代码调试，以及常见的调试技巧。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java语言基础Day012011/7/29====================1.Linux简介1)文件系统2)当前工作目录,就是当前正在使用的默认文件夹文件夹=目录pwd打印(显示)当前工作目录3)用户主目录(user home),是属于当前登录用户个人的目录个人主目录,用户拥有对自己用户主目录全部管理权限.4)mkdir创建文件夹mkdir demo在当前文件夹(工作目录)里创建文件夹demo5)cd切换(更改)当前工作目录..代表上层目录,cd..切换到上层目录.代表当前目录cd指定的目录cd/到跟目录cd/home/liucs到主目录cd命令默认返回用户主目录(user home)6)ls显示文件夹内容7)绝对路径和相对路径A以跟(root)"/"为开始的路径是绝对路径B不是以"/"开始的是相对路径,相对路径默认相对于当前目录8)rm-rf dir删除目录9)启动eclipsecd/opt/eclipse./eclipse2.Java简介1)java特点:简单,面向对象,跨平台,安全,多线程支持2)java的跨平台Java通过JVM实现了跨平台技术Java源代码（*.java）经过Java的编译器编译成Java字节码（*.class）,执行Java字节码，Java字节码经过JVM的解释为具体平台的具体指令，并执行。
不同平台有不同的JVM，主流平台都提供了JVM。
所以JAVA字节码可以在所有平台上能够解释执行。
在这个意义上Java是跨平台的。
也就是说：Java的字节码是跨平台的。
3)Java JDKJDK java开发工具包/opt/jdk or/opt/jdk_1.6.01|--bin开发工具(命令：java,javac,jar,javad,jar,rmic,jps...) |--jre JRE Java运行环境|--lib(rt.jar)Java API(应用编程接口，系统类库)|(java提供的现成组件)|--bin(java_vm)JVM Java虚拟机3.Java APP1)HelloWorld.javapackage basic.day01;/***eclispe自动将当前文件编译到：*workspace/JSD1105/bin/basic/day01/HelloWorld.class *(工作空间/项目/bin/包文件夹/类文件)*执行时候,执行这个类文件.*@author teacher*/public class HelloWorld{//java软件的入口方法public static void main(String[]args){//在控制台输出“Hello World!”System.out.println("Hello World!");}}2)Java的编译project|--src||--basic.day01|||--HelloWorld.java||--basic.day02|||--JFrameHelloWorld.java|--bin||--basic.day01|||--HelloWorld.class||--basic.day02|||--JFrameHelloWorld.class4.Java的注释，被Javac(编译器)忽略的部分1单行注释//...2多行注释/**/3文档注释/***/5.Eclipse(日食/月食)1)来自IBM开源,有基金会维护开发是主流的Java开发平台,可以开发:PHP,Ruby,AndroidSUN对这个软件很有意见.eclispe是Java开发的,需要JDK来运行2)下载3)JDK:预习:java变量类型,运算符等Java语言基础Day022011/8/1====================1.Java变量1)变量就是自然语言中的代词Person he;int age=15;//age=00000000000000000000000000001111System.out.println(age);//152)Java中的变量,Java是强类型语言，A变量必须声明，并且初始化以后使用B变量必须有明确的类型C变量不能重复定义3)变量的作用域a在声明的地方开始，到块结束为止b离开变量的作用域结束，变量将回收。
2.进制转换基础1)十进制逢10进1基数:10权:10^n,10000100010010123678(10)=2*10000+3*1000+6*100+7*10+8*1=2*10^4+3*10^3+6*10^2+7*10^1+8*10^0=236792)二进制逢2进1基数:2权:2^n,128643216842101000001(2)=1*64+1*1=65(10)3)补码基础-1281000000011111111111111111111111110000000 102进制......84211111011111111111111111111111111111110111 -810001111100011111111111111111111111111111000 -7100111111001-6101011111010-5101111111011-4110011111100-3110111111101-2111011111110-1111111111111000000000000010001000000012001000000010300110000001140100000001005010100000101601100000011070111000001110000100000000000000000000000000000001000.......1270111111100000000000000000000000001111111补码运算:-11111-11111*----------1111111111111111101010-----------00014)A Java内部只有二进制补码B Java内部采用补码运算,自动发送上溢出和下溢出C Java内部没有10进制!但是Java尽量按照人类习惯输入输出D补码的负数最高位是1,也称作符号位5)16进制,是2进制的简写,方便专业人员书写2进制数据16进制逢16进1基数:16权:16^n,25616116进制数字:0123456789a b c d e f012345678910111213141541(16)=4*16+1*1=65(10)=01000001(2)8421842141(16)128643216842101000001练习:转换以下十进制为二进制192(10)137(10)145(10)192(10)=11000000(2)c0(16)-8(10)=fffffff8(16)3.Java数据类型:分为引用类型和基本数据类型1)基本数据类型:8种byte,short,int,longfloat,doublecharboolean2)整数类型byte,short,int,long,都是有符号(补码)整数byte8位补码最大值0x7f127最小值0x80-128short16位有符号数0x7fff327670x8000-32768int32位0x7fffffff2G-12^31-121亿0x80000000-2Glong64位....整数字面量(直接量)默认是int类型,如果不超出范围,可以给小类型直接赋值.使用整数类型(byte,short,int)要注意取值范围,超范围运算java底层byte,short按照32位计算;long类型的字面量使用"L","l"后缀3)浮点数,小数(不必掌握浮点数的存储方式)浮点数原理:10进制浮点数(科学计数法)原理2356189.=2.356189*10^6概念:尾数:2.356189指数:6基数:10pi=3.143.1415926535897932384626433二进制浮点数:101001010101.= 1.010*********2^1011概念:尾数:1.010********指数:1011基数:2float:32位其中:1位符号位,8位指数,23位尾数精度:23位int max=01111111111111111111111111111111float f= 1.11111111111111111111111*2^00011110double:64位其中:1位符号位,11位指数,52位尾数浮点数的字面量:默认是double,D d后缀是double,f F是float4)字符类型char,字符是一个16位无符号整数,是一个二进制数数值是一个字符的unicode编码值.unicode编码:是全球范围内的编码方法,编制了英文,中,日,韩,阿拉伯,希伯来,..... 8万+字符.其中英文部分与ASCII兼容,英文字符和数字是连续编码的.ASCII:0~128Java char的范围0~65535不能表示全部unicode但是可以表示unicode只能够最常用的部分*最小值:0,最大值:65535=2^16-1*字符字面量使用单引号为定界符号:'中'字面量也是整数常量!特殊字符采用转义字符表示:如:'\n''\t''\\''\b''\r''\'''\"''\u4e2d'char c='\\';5)boolean布尔类型表达:真(true)/假(false)建议使用长变量名定义变量boolean started=true;boolean isMan=true;isMan=false;boolean used=true;//二手的if(used){System.out.println("打八折");}不建议定义没有意义的变量boolean u=true;//u=youboolean flag=false;if(flag){System.out.println("打八折");}4.数据类型转换char->byte->short->int->long->float->double1)自动类型转换,正方向,小类型到大类型的转换会自动完成符号位会自动扩展,负数补1,正数补0,保证补码数值不变注意,整数到浮点数转换会损失精确度自动类型转换也叫"隐式类型转换",是自动发生的,一般不需要处理int i=-1;long l=i;2)强制类型转换(显示类型转换),需求明确处理,是按照反方向,进行的转换,这种转换会溢出,或者损失精度.要注意数据的范围int i=128+256;//00000000000000000000000110000000byte b=(byte)i;//-128long l=0xf80000000L;int c=(int)l;//负数l=8;int d=(int)l;float pi=(float)3.1415926535;//损失精度char c='0';char x=(char)(c+2);作业:1复习并且完成全部课堂演示代码,添加适当的输出语句,研究输出结果,添加适当的注释.2尝试计算10个以上255以内的整数转换为2进制,16进制,相互转换.并且编程验证计算结果提示:System.out.println(Integer.toHexString(234));3(选做)定义方法:参数是一个整数类型,没有返回值,在方法中输出这个整数的10进制,2进制,16进制字符串4尝试实现day02.png中的案例,在周末提交结果5将人名字符的HEX编码输出,手工转换为二进制,并且验证结果提示:可以使用Scanner输入用户数据预习:Java运算符,流程控制语句.参考Day03.txtJava语言基础Day032011/8/2====================1.Java的方法Method(函数Function)1)方法就是函数:y=f(x)=3x+6;2)方法的语法(修饰词)(返回值类型)(方法名)(参数列表){//方法体}如:public static int f(int x){int y=3*x+4;return y;}4)如果有返回值定义就必须有return语句,返回和返回值类型兼容的数据5)方法的参数和方法内部的变量都是局部变量,这些变量作用域只在方法内部!6)实参:方法调用时候实际传递的参数变量形参:方法的参数定义,是临时变量.2.Java运算符1)数学运算符+-*/%A运算的封闭性(补码运算的封闭性):1.同种类型参与运算(可能需要自动类型转换)2.返回同种类型(可能发生:上溢出和下溢出)3.byte,short,char按照int运算如:int a=1+'A';B.整数的除法是整除,除以2相当于移位运算(移动小数点)C.Java中字面量的运算被Javac优化了,优化为一个固定的常量.D.%计算除法的余数1.0对其他数的余数是02.n%3是周期函数,函数值[0,3)3.负数的余数是负数(考试可能出现,工作中很少用)2)自增(自减)运算++--1.可以将当前变量自我增加(减少)12i++,后++,先将i的值作为整个表达的值,然后将i增加1.3++i,先++,先将i增加1,然后将i的值作为整个表达的值.3)逻辑与比较运算1.逻辑运算与(并且)&&或(或者)||非(否则)!非短路的逻辑运算&|,比较少使用,逻辑不合理2.比较运算,比较变量的值,就是逐个"位"比较值:>>=<<===!=基本类型变量的值就是基本值如:i=1引用类型变量的值是对象地址值.(在面向对象阶段详细讲解)int i=1;long l=1;System.out.println(i==l);//true4)条件运算符(3元运算符)语法:条件表达式?表达式1:表达式2当"条件表达式"为true时候,表达式1作为整个表达式的值,否则表达式2作为整个表达式的值如:boolean isBoy=true;int level=isBoy?2:3;//23.分支流程控制1)if...else语法:if(布尔表达式){//语句块..}else{//语句块}嵌套:if(布尔表达式){//...}else if(布尔表达式){//...}else if(布尔表达式){//...}else{//...}2)switch...case语法:switch:开关,case:情况下switch(整数表达式){case整数常量1://语句序列break;case整数常量2://语句序列break;default://语句序列}A.switch条件:只能是整数(int byte char short)表达式switch不能处理long或其他类型B.case只能是整数(int byte char short)常量,不能使用变量及表达式.如:'中'C.break跳转到switch结束继续执行,可以根据业务逻辑是否使用经常都写break4.循环控制1)While循环控制语法:while(布尔表达式){//循环体语句序列}作业:1复习并且完成全部课堂演示代码,添加适当的输出语句,研究输出结果,添加适当的注释.2重构课堂案例,将参数通过Scanner输入3重构课堂案例,加入while循环,增加输入信息合理性判断.4(选做)案例练习输出等额本息还款计划表如(示例):月份本金利息归还第1月9307121642第2月9407011642......预习:流程控制语句for(),do...while,Java数组.参考Day04.txti++%b(int)a+by=g(x)=3*x*x+2*x+4;Java语言基础Day042011/8/3====================1.whileWhile循环控制Scanner console=new Scanner(System.in);while(布尔表达式){qty=console.nextInt();if(qty>0&&qty<=5){//五个以内break;//打断,打断当前循环}}2.for循环(主要用于几次的循环)循环控制for(初始化表达式;布尔表达式;递增表达式){//循环体}Example:for(int i=0;i<array.length;i++){System.out.println(i);}3.do...whiledo...while()循环控制do{//循环体}while(布尔表达式);Example:do{System.out.print("输入押注数量:");bet=console.nextInt();}while(bet<=0||bet>balance);//否定条件4.Java Array1)数组变量的声明int[]ary;声明了数组变量ary,数组变量是代词,int ary[];为了与C语法兼容的写法,不建议写法,2)数组对象动态初始化ary=new int[4];//数组变量引用了具体数组对象,就是代词指代了具体事务.数组元素是自动初始化的,自动初始化为"零"值."零"值:0,0.0,\u0000,false,nullary=new int[]{1,2,3};直接给出元素的初始化3)数组对象的静态初始化,只能用在声明数组变量时候同时初始化*不能用于赋值语句int[]ary={1,2,3};ary={3,4,5,6};//编译错误Java关键字:if,public,class,else,while特殊关键字:goto,constjava中true,false,null不是关键字,是字面量!4)数组变量,数组对象,数组元素如:int[]ary={1,2,3};ary是数组变量指代一个具体的数组,同一个变量指代不同的数组{1,2,3}数组对象1,2,3是数组元素5)数组元素的访问,数组对象的大小是固定的,长度是n,下标:0~n-1A使用[下标]访问数组元素B越界访问(小于0/大于等于n),都会发生运行异常C使用.length属性可以获取数组对象长度5数组的复制与动态扩展算法1)数组对象的复制2)数组的扩展问题1Java数组对象的大小是固定的,数组对象是不能扩展的2利用数组复制到方法可以变通的实现数组扩展3System.arraycopy()可以复制数组4Arrays.copyOf()可以简便的创建数组副本5创建数组副本的同时将数组长度增加就变通的实现了数组的扩展案例1:统计一个字符在字符串中的所有位置.字符串:统计一个字符在字符串中的所有位置字符:'字'返回:{4,7}6)数组的迭代:将每个数组元素重复的处理一遍.for(int i=0;i<ary1.length;i++){System.out.print(ary1[i]+"");}作业:1复习并且完成全部课堂演示代码,添加适当的输出语句,研究输出结果,添加适当的注释.2实现案例:案例1:统计一个字符在字符串中的所有位置.字符串:统计一个字符在字符串中的所有位置字符:'字'返回:{4,7}public static int[]count(String str,char key){}char key='字';String str="统计一个字符在字符串中的所有位置";int[]count={};for(int i=0;i<str.length();i++){char c=str.chatAt(i);if(c==key){//扩展数组,count=Arrays.copyOf(count,count.length+1);//添加序号icount[count.length-1]=i;}}案例2:统计一个字符在字符数组中的所有位置.字符数组:统计一个字符在字符串中的所有位置字符:'字'返回:{4,7}案例3:字符串统计案例:字符串:"123456789012"将字符串的奇数位数字相加为c1=1+3+5+7+9+1将字符串的偶数位数字相加为c2=2+4+6+8+0+2案例4:(选做)将一个整数数位翻转如:整数56123返回结果为整数:32165提示:使用%10获取最后一位使用/10去除处理完的最后一位预习:数组的排序.Java语言基础Day052011/8/4====================1.常见排序算法,学习目的:不是为了工作使用!练习使用for循环和数组,有些面试题中会出现.在实际工程项目中有现成的优化的排序API1)选择排序原理:a将数组中的每个元素,与第一个元素比较如果这个元素小于第一个元素,就将这个两个元素交换.b每轮使用a的规则,可以选择出一个最小元素放到第一个位置.c经过n-1轮比较完成排序简单说:每轮选择最小的放到前面.原理说明:ary={8,2,3,7,1}ary={1|8,3,7,2}ary={1,2|8,7,3}ary={1,2,3|8,7}ary={1,2,3,7|8}代码分析:i代表第一个数据的位置j代码后部每一个数据的位置ary i j ary[i]ary[j]ary[i]>ary[j][i]<->[j]{8|2,3,7,1}0182true8<->2{2|8,3,7,1}0223false{2|8,3,7,1}0327false{2|8,3,7,1}0421true2<->1{1,8|3,7,2}1283true8<->3{1,3|8,7,2}1337false{1,3|8,7,2}1432true3<->2{1,2,8|7,3}2387true8<->7{1,2,7|8,3}2473true7<->3{1,2,3,8|7}3487true8<->7{1,2,3,7,8}4i=0~<ary.length-1;j=i+1~<ary.lengthif(ary[i]>ary[j]){//ary[i]<->ary[j]int temp=ary[i];ary[i]=ary[j];ary[j]=temp;}2)冒泡排序原理:a逐一比较数组中相邻的两个元素,如果后面的数字小于前面的数字,就交换先后元素.b经过一个轮次的比较,一定有一个最大的排在最后的位置.c每次比较剩下的元素,经过n-1次比较,可以实现排序.简单说:比较相邻元素,大的向后交换原理说明:ary={8,2,3,7,1}ary={2,8,3,7,1}ary={2,3,8,7,1}ary={2,3,7,8,1}ary={2,3,7,1|8}ary={2,3,7,1|8}ary={2,3,7,1|8}ary={2,3,1|7,8}ary={2,3,1|7,8}ary={2,1|3,7,8}ary={1,2,3,7,8}i代表次数j代表比较位置ary i j j+1ary[j]ary[j+1][j]>[j+1][j]<->[j+1]{8,2,3,7,1}00182true8<->2{2,8,3,7,1}01283true8<->3{2,3,8,7,1}02387true8<->7{2,3,7,8,1}03481true8<->1{2,3,7,1|8}10123false{2,3,7,1|8}11237false{2,3,7,1|8}12371true7<->1{2,3,1|7,8}20123false{2,3,1|7,8}21231true3<->1{2,1|3,7,8}30121true2<->1{1,2,3,7,8}i=0~<ary.length-1j=0~<ary.length-i-1;if([j]>[j+1]){[j]<->[j+1]}3)插入排序原理:a将数组分为两部分,将后部分的第一张逐一与前部分每一张比较,如果当前元素小,就一点被比较元素.b找到合理位置插入.原理说明:temp=1{8|2,3,7,1}{2,8|8,7,1}{2,3,8|7,1}{2,3,8|8,1}{2,3,7,8|8}{2,3,7,7|8}{2,3,3,7|8}{2,2,3,7|8}{1,2,3,7|8}temp代表取出的待插入元素i代表后组待插入元素位置j代表前组每个元素的位置(移动)插入ary i t j ary[j]t<[j][j]->[j+1]t->[j+1]{8|2,3,7,5}1208true8->[j+1]{8|8,3,7,5}12-12->[j+1]{2,8|3,7,5}2318true8->[j+1]{2,8|8,7,5}2302false3->[j+1]{2,3,8|7,5}3728true8->[j+1]{2,3,8|8,5}3713false7->[j+1]{2,3,7,8|5}4538true8->[j+1]{2,3,7,8|8}4527true7->[j+1]{2,3,7,7|8}4513false5->[j+1]{2,3,5,7|8}5i=1~<ary.length,i++t=[i];j=i-1~>=0,j--if(t<[j]){[j]->[j+1]//移动}else{break j;}t->[j+1]//插入2.java系统排序Arrays.sort(),排序算法性能很好3.方法的递归调用1)java的栈:是Java进程启动时候在内存中开辟的存储空间栈内存的利用方式LIFO(后进先出).Java所有局部变量都在栈中分配(压入),方法的参数也是局部变量,局部变量在离开作用域时候回收就是从栈中弹出(删除).2)Java方法调用使用栈实现,递归调用就是栈实现的3)递归时候要按照递归深度分配全部临时变量,栈开销很大,性能不好,要注意不要超过栈的大小,并且一定要给出结束条件,否则会造成栈溢出错误.案例：1+2+3+...+n=f(n)=n+f(n-1)&&(n>0,f(1)=1)注意事项:解决问题简练，性能很差。