java课堂笔记
(完整版)Java学习笔记(必看经典)
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：有什么（属性）：用来描述对象。
能够做什么（方法）：告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数，也可能有返回值。
注意区分：对象（本身）、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象，类是对象的抽象。
其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。
这样才能使每个对象本身做成最好的。
对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。
在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：class Student{代码}注意类名中单词的首字母大写。
局部变量：定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
实例变量的对象赋值为null。
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;}}}。
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_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课堂笔记
✧Char、byte、short进行算术运算时自动转换为Int类型。
✧String【】一个类，args用来存放该类对象的地址。
✧String s=“Hello World”中，s不是一个对象，s为一个变量，存放的是对象“Hello World”的地址。
✧对象就是内存在堆区中的一块空间。
✧主方法可以不放在主类中，但是通常都是放在主类中的。
✧将一个float或double值转换成整数值后，总是将小数“部分”砍掉，而不是四舍五入。
✧在Math.random()输出的范围是【0，1).✧GC:garbage collection（垃圾回收）。
✧根源网站✧OA：office automation（办公自动化）✧算法口诀：冒择路（与插入的“入”子谐音）希快堆归。
✧内部类：在类内不再定义的类称为内部类。
✧内部类的访问权限有：private、protected、public、还有就是默认的包访问权限。
✧一般类的访问权限主要有：private、public✧构造器就是构造函数，他们的概念是一样的。
✧Java中的包是和目录结构对应的。
✧对象在堆区中开辟空间，类在方法区中开辟空间，对象的引用一般在栈区中开辟空间。
✧有参的构造方法能完全覆盖无参的构造方法，默认的无参的构造方法将不复存在，如果需要同时保持无参的默认的构造函数，需要自己重新写一遍。
✧Public Class person{public static void main(string args[]){Public int age;……..}}Class test{Person p1=new person();s.age(此用法是对的，因为age属性的访问控制符为public为公有访问。
也可以调用s.setAge()方法设置age的值)}✧Java源文件的基本结构：1.包的申明（默认申明到当前目录）2.包的导入（默认为import ng.*;）3.类的引用✧在当前目录包下申明一个包用来存放字节码文件。
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课堂笔记
配置环境变量：右击我的电脑--属性--单机环境变量--单机新建--分别设置用户环境变量和系统环境变量基础语法1.基本数据类型boolean（布尔型）byte（字节型），short（短整型），int（整型）long（长整型），char（字符型），浮点型（float，double）2.操作符+，-，*，/，%（取余），++，--（i++，给i加1在加一前赋值；++i，给i加1在加1后赋值；i--，给i减1在减1前赋值；--i，给i减1在减1后赋值）3.java语言的基本组成标识符（java中的一些名称(合法标识符:不可以数字开头；不可以使用关键字；严格区分大小写)）、关键字（被java赋予特殊含义的单词）、分隔符（. ；：）注释（//单行注释(可以住是自身也可以注释多行注释和文档注释)；/*.....*/多行注释(不可以注释自身)；/**.....*/文档注释(一般放在类名上面，通常写该类做什么，日期多少，作者和版本号)）public（访问修饰符，有public类名必须跟文件名一致）成员变量（紧跟着外层大括号(类的大括号)就是成员变量局部变量（在函数中的变量都是局部变量）强制类型转换（容量大的类型转为容量小的类型）4.判断if(i){}，i的值为false跳转到if语句的末尾（“}”），值为true在屏幕中显示true。
if(i){}...else{} if条件为false执行elseswitch语句可以和if语句完成一样的功能，判断单个数字或者枚举值类型时应选择switch 语句break能阻止选择结构，跳出选择结构，应用范围：选择结构和循环结构；在switch用于终止当前分支，在大多数情况下是必要的，没有break语句时，switch语句会直接执行下一个分支语句。
5.循环while循环满足条件时进入循环，不满足跳出，流程：判断循环条件--条件表达式只能返回一个布尔值，如果条件为true执行语句块，如果为false直接退出循环--再一次判断条件--直到条件为falsedo-while循环是在后面检测循环条件，循环体中的语句被执行至少一次，流程：先执行循环体--检测条件--条件为false，退出--条件为true 进入下一次循环for循环的执行流程：循环初始化--检测循环条件，不满足退出--执行循环体--循环迭代；使用for循环时，初始化表达式只执行一次，就是当循环开始的时候，只要循环表达式为假，就中断循环，如果为真就死循环。
JAVA课堂笔记基础-详细解释
JA V A编程基础—课堂笔记详解1）课程使用的开发环境：●bin:文件中主要是包含我们今后要用到的命令●lib:主要包含java开发过程中要用到的java包2）环境变量的配置●如果使用ecplise等开发工具，则不配置环境变量也是可以正常使用jdk等功能，但是在dos中却使用不了，配置环境变量则可以在dos中使用●步骤：右击我的电脑—》属性—》高级—》环境变量—》编辑系统变量中的path（在path后面加上一个“；”号，再将bin文件路径C:\Program Files\Java\jdk1.6.0_11\bin加上去——》查看系统变量中是否有classpath变量，如果没有则——》新建——》classpath，将“.;C:\Program Files\Java\jdk1.6.0_11\lib”附加到classpath后面——》确定。
3）在dos中运行java程序●通过cd命令找到java文件所在的路径●编译：javac helloworld.java——注意此处文件名的大小写要区分●编译完成后会出现一个helloworld.CLASS文件●运行：java helloworld——不加扩展名，真正运行的是.class文件●注意：java文件名字必须与文件中具有public static void main()类的名字是一样4）●java虚拟机的作用是将字节码文件解释成机器语言；不同的操作系统平台要安装不同的JDK；●java是一种半编译半解释的文件；源文件——》字节码：编译方式●字节码——》机器代码：解释方式5）使java的格式优化：source->format：优化文档格式6）在dos中提取java文档的信息（提取文档注释的信息）javadoc -d textdoc -version -author helloworld.java7）当在数字后面加上一个L时，则系统会认为它是一个长整形；●同样在一个浮点数后面加上F/D系统就会认为它是单精度活或者双精度；●转义字符例如：‘\n’是一个字符，同时Unicode编码也是一个字符，例如‘\’;因此区分字符和字符串是通过双引号/单引号区分而不是字符的长度区分。
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笔记
1.前言 (4)1.1.JA V A特点 (4)1.2.运行原理 (4)1.3.JA V A目录 (4)2.一.基础知识 (4)2.1.配置环境 (4)2.2.Java中基本概念 (5)3.二.定义，关键字和类型 (5)3.1.注释的三种形式 (5)3.2.Java代码中的“；”、“{}”、“” (5)3.3.标识符 (5)3.4.数据类型 (6)3.5.命名规则 (6)4.三.表达式和控制流 (6)4.1.变量和作用域 (6)4.2.操作符 (7)4.3.数字类型之间的转换 (7)4.4.强制类型转换 (8)4.5.转换的二种类型 (8)4.6.控制流 (8)4.7.循环语句 (8)5.四.数组 (9)5.1.声明数组 (9)5.2.创建数组 (9)5.3.初始化数组 (10)5.4.多维数组 (10)5.5.数组拷贝 (10)6.五.对象和类 (11)6.1.面向对象与面向过程 (11)6.2.对象的概念 (12)6.3.成员变量和局部变量 (12)6.4.成员方法 (12)6.5.This关键字 (13)6.6.访问控制符 (13)6.7.构造方法 (13)6.8.数据和方法的隐藏―――封装 (14)6.9.方法的重载 (15)7.六.高级语言特性 (15)7.1.封装(encapsulation) (15)7.2.继承(inherit) (16)7.2.1.JA V A继承特点 (16)7.2.2.父类（SuperClass）和子类（SubClass）的关系 (17)7.2.3.系统构造一个对象的顺序 (17)7.3.多态(polymorphism) (18)7.3.1.方法的覆盖（overridding） (18)7.3.2.多态的分类 (18)7.3.3.运行时多态的三原则 (19)7.3.4.关系运算符：instanceof (20)7.4.静态变量，方法和类 (20)7.5.Singleton模式 (22)7.6.final关键字 (22)7.6.1.final变量不能被改变; (22)7.6.2.final方法不能被改写; (23)7.6.3.final类不能被继承; (23)7.6.4.String 类 (23)7.7.抽象类 (24)7.8.接口(模板方法模式) (25)7.9.Object 类 (27)7.10.封装类 (28)7.11.内部类 (29)7.11.1.内部类的分类 (29)7.11.2.成员内部类 (29)7.11.3.局部内部类 (30)7.11.4.静态内部类 (30)7.11.5.匿名内部类 (31)7.12.集合 (31)7.12.1.集合接口类层次 (32)7.12.2.集合类层次 (33)7.12.3.五个最常用的集合类之间的区别和联系 (33)7.12.4.比较 (35)7.13.反射 (37)8.七.异常 (37)8.1.异常的基本概念 (37)8.2.捕获异常 (38)8.3.处理异常 (38)8.4.捕捉多个异常 (38)8.5.finally 声明 (38)8.6.异常调用栈 (39)8.7.异常层次 (39)8.8.一些未检查的异常 (39)8.9.写你自己的异常 (39)8.10.抛出你自己的异常 (40)9.八.图形用户接口 (40)10.九.AWT（Abstract Window Toolkit）事件模型 (41)11.十.The AWT Component Library (41)12.十一.JFC（Java Foundation Classes） (41)13.十二.Applets (41)14.十三.线程Thread (41)14.1.线程原理 (41)14.2.线程实现的两种形式 (42)14.3.线程的生命周期 (43)14.4.Thread的方法 (43)14.5.共享数据的并发处理 (44)14.6.使用互斥锁的注意事项 (44)15.十四.标准I/O流与文件 (46)15.1.对文件的操作 (46)15.2.处理跨平台性 (46)15.3.对象的序列化接口 (47)15.4.I/O流基础 (47)15.5.流的分类 (47)15.6.I/O输入输出 (48)16.十五.网络编程 (52)16.1.网络基础知识 (52)16.2.TCP Socket (54)16.2.1.建立TCP服务器端 (54)16.2.2.建立TCP客户端 (55)16.3.建立URL连接 (55)16.4.UDP socket (58)16.4.1.建立UDP 发送端 (58)16.4.2.建立UDP 接受端 (59)17.java5.0的新特性 (60)17.1.泛型 (60)17.1.1.说明 (60)17.1.2.用法 (61)17.1.3.泛型的通配符"?" (62)17.1.4.泛型方法的定义 (63)17.1.5.泛型类的定义 (64)17.1.6.泛型与异常 (64)17.1.7.泛型的一些局限型 (66)17.2.增强的for循环 (66)17.3.自动装箱和自动拆箱 (69)17.3.1.在基本数据类型和封装类之间的自动转换 (69)17.4.类型安全的枚举 (70)17.5.静态引入 (71)17.6.C风格的格式化输出 (71)17.7.Building Strings(StringBuilder类) (72)17.8.可变长的参数 (72)17.9.JA V A5.0 的注释(Annotation) (72)17.10.Callable 和Future接口 (73)JA V A数据库连接：JDBC1.前言1.1. JAVA特点1) 简单(Java语法是C++语法的一个“纯净”版本)；2) 可移植性(一次编译到处运行)3) 面向对象4) 分布式(Java把打开套接字连接等繁琐的网络任务变得非常容易)5) 健壮性(Java编译器会检查出很多其他语言在运行时刻才显示出来的错误；Java采用的指针模型可以消除重写内存和数据崩溃的可能)6) 多线程(多线程编程的简单性是Java成为流行的服务器端开发语言的主要原因之一)7)安全(用Java可以构建防病毒和防篡改的系统)9) 动态(Java可随意增加新的方法以及实例变量，而客户端却不需做任何的更改)10)体系结构中立(字节码与计算机体系结构无关，只要存在运行时系统，可在多种处理器上执行)1.2. 运行原理先编译*.java文件――――>*.class文件运行*.class ――加载――> JVM（JA V A虚拟机）1.3. JAVA目录JRE―――――――运行环境SRC――――――－类库BIN―――――――应用程序2.一·基础知识2.1. 配置环境LINUX系统（修改环境配置文件）1 打开shell2 vi .bash_profile3 JA V A_HOME=JA V A目录路径4 PATH=$JA V A_HOME/bin:其他路径5 CLASSPATH=.6 export JA V A_HOME CLASSPATHWindows系统我的电脑属性―――>环境变量设置环境变量：JA V A_HOME=路径PATH = %PATH%;c:\j2sdk1.4.2_05\bin;CLASSPATH = .;2.2. Java中基本概念1) 源文件在最顶层只包括一个public类型的类/接口，文件名与类/接口名同并以.java作为文件后缀。
java课堂笔记
目录第一本书 (4)第一章 (4)使用my eclipse开发java程序的步骤 (4)常用快捷键 (4)Myeclipse常用设置： (4)第二章 (4)变量的使用方法 (4)程序编写规范 (4)变量的命名规范 (4)Scanner的用法 (4)三元运算符 (4)赋值运算符 (4)关系运算符 (5)逻辑运算符 (5)运算符的优先级 (5)第三章 (5)单分支选择结构语法 (5)多分支选择结构 (5)嵌套分支选择结构 (5)Switch选择结构语法 (6)第四章 (6)循环结构 (6)程序调试步骤 (6)Break与continue的用处 (7)第五章 (7)数组 (7)二维数组 (7)标志变量的用法（可用于循环中结束语句） (7)第六章 (7)类与对象 (7)局部变量与成员变量的区别 (8)定义带参数的方法 (8)基本数据类型和引用数据类型在传参时区别 (8)作用是用来创建类的对象 (8)Static的作用 (9)方法的重载 (9)第七章． (9)继承和多态（extends） (9)多态 (9)方法的重写 (9)抽象类与接口 (10)Instanceof的用法 (10)第九章 (10)异常 (10)Log4j (11)第二本书 (11)第一章（集合框架和泛型） (11)集合框架和泛型 (11)ArrayList类的的常用方法 (12)LinkedList类的常用的方法 (12)HashSet类的常用方法 (12)Map接口的常用方法 (12)Collections的用法 (13)List迭代器用法 (13)Hashmap迭代器的用法 (14)Hashmap Foreatch的用法 (14)Foreatch的用法 (14)第二章（实用类） (14)实用类 (14)第三本书 (15)静态网页制作 (15)第二章 (20)Javascript (20)JS的数据类型 (20)数据类型的转换 (21)常用的输入/输出/确认 (21)For....in循环语句 (21)常用系统函数举例 (21)function函数 (21)事件驱动 (21)History属性 (21)Dom的属性及操作方式 (22)下拉列表关联 (23)获得滚动条滚动的距离 (24)表单验证 (24)正则表达式 (24)调用函数间隔事件 (24)第三章jqurey (25)jqurey (25)Jqurey选择器 (25)Jqurey事件驱动 (26)Html代码操作 (28)HTML5 (29)数据库的创建与类型 (35)数据库的管理 (36)使用BDL查询数据库 (37)高级查询 (38)Oracle (38)日期格式的修改 (38)Rowid与rownum (38)对数据表的操作 (39)操作符 (39)转换函数 (39)三种排序方式 (39)第四本书 (40)Jsp的基本语法 (42)Request对象 (42)Session对象 (42)Application对象，设置页面访问次数 (43)cookie对象 (43)使用JDBC操作数据库 (43)使用PreparedStatement防止SQL语句注入 (44)通过连接池获得connection (44)通过配置文件获取数据 (44)所见即所得 (45)El表达式 (45)Servlet (46)过滤器的作用 (47)AJAX (47)综合项目注意事项 (48)语句整理 (61)第一本书第一章使用my eclipse开发java程序的步骤1.新建一个项目（new java project）2.在项目中新建一个包（new package）3.在包中新建一个java4.运行程序：run常用快捷键1.注释（ctrl+shift+/），取消注释（ctrl+shift+\）2.输出语句：输入syso，然后按住（alt+/）3.格式化代码：Ctrl+A（全选），然后Ctrl+I（格式化规格）4.\t 空一格Myeclipse常用设置：1.菜单：window-perference-font（字体设置）window-show view（显示窗口：packge，explore（项目导航）conssole（控制台））将项目导入：Myeclipse：Import-General-Existing将项目导出：选中项目ctrl+c，第二章变量的使用方法程序编写规范1.一行只写一个语句2.一行语句结束后，加一个分号3.Class名称，首字母大写4.字符串用双引号5.字符用单引号（char）程序默认从上到下执行变量的命名规范1.组成：字母，数字，_，$，2.首字母：字母，_，$,3.不能使用关键字4.看见要知道其意思（name为名字的意思）5.骆驼命名法：classname写成className或者classNamePublicScanner的用法1.可以接收用户键盘输入的字符三元运算符Int a=2;Int b=3;Int c= a==b? a*b: a/b; 含义为：当a==b成立的时候，运行冒号前面的公式，不成立的时候运行冒号后面的公式，赋值运算符1.变量名=表达式2.表达式就是符号（+.，-）与操作数：变量与常量3.满足自动类型转化的条件：类型要一样，小字节可以转到大字节不能反过来强制装换:int befor=20; double rise=9.8; int now=befor+(int)rise; 关系运算符1. 1.=为赋值运算符，==为关系运算符2.关系表达式的结果是一个布尔值(boolean)，3.>, <, >=, <=运算符的优先级别高于==,！=;4.>, <, >=, <=只支持数值类型的数据比较；逻辑运算符1.逻辑与（&&）两个都是正确的，结果才是正确的2.逻辑或（||）两个操作一个是正确的，结果就是正确的3.逻辑反（！）如果正确则输出错误，反之正确4.操作类型只能是布尔类型，操作结果也是布尔类型5.运行优先级别！运算符的优先级1.最高的优先级是：小括号（）2.最低的优先级是：赋值运算符=3.优先级顺序：算术运算符>关系运算符>逻辑运算符4.如果運算較多，則可以加小括弧来控制順序第三章单分支选择结构语法a)if选择结构的语法if（条件）{条件为真时执行的代码块}else{ 条件为假时执行的代码块}2.比较两个字符串用[“键盘输入的内容”.equals（定义的内容）]多分支选择结构1.结构语法If（条件1）{条件1为真时，执行的代码块}else if（条件2）{条件2为真时，执行的代码块} else {条件1和条件2都不满足时，执行的代码块}嵌套分支选择结构If（条件1）{If（条件2）{同时满足条件1和条件2，执行的代码块}else if（条件3）{同时满足条件1，满足条件2，执行的代码块} } else {条件1不满足时，执行的代码块 }Switch 选择结构语法Switch （表达式）{ Case 常量：表达式等于常量1时，执行的代码块 Break; //终止程序 Case 常量2：表达式等于常量1时，执行的代码块 Break; //终止程序 Default ：不等于上述任何一个常量时，执行的代码块Break; }第四章循环结构1. 循环结构的特点：由循环条件和循环操作组成2. 语法：先判断后操作，当满足的时候循环才会停止，3. 循环步骤： ● 确定循环条件和循环操作 ● 套用while 语法写出代码 ●检查循环是否能退出While 循环 循环条件）{循环操作 }Do while 循环 1. 语法结构Do {循环操作Break与continue的用处终结语句，结束循环，跳到循环块外的下一条语句常用于switch结构和循环结构中2.continue结束本次循环，重新开始下一次循环。
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的特点..............................................................Java开发环境............................................................Java开发环境配置........................................................（Linux命令与相关知识.....................................................Eclipse/Myeclipse程序结构...............................................二、 Java语言基础 ...........................................................基础语言要素..............................................................八种基本数据类型..........................................................常量和变量................................................................运算符与表达式............................................................编程风格..................................................................:流程控制语句..............................................................数组......................................................................字符串....................................................................方法三要素................................................................冒泡排序..................................................................冒泡排序：轻气泡上浮的方式................................................二分法查找................................................................~Java系统API方法调用....................................................二进制基础................................................................Java基础其他注意事项....................................................三、面向对象................................................................类 .......................................................................对象......................................................................包 .......................................................................方法及其调用..............................................................。
达内科技Java学习笔记(经典必看)
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：//有什么（属性）：用来描述对象。
能够做什么（方法）：告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数，也可能有返回值。
注意区分：对象（本身）、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象，类是对象的抽象。
其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。
这样才能使每个对象本身做成最好的。
对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。
在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：class Student{代码}注意类名中单词的首字母大写。
局部变量：定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
实例变量的对象赋值为null。
java课堂笔记
星期二：路漫漫；
星期三：曙光在前；
星期四：生死搏斗；
星期五：黎明前的黑暗；
星期六：虎口脱险；
星期日：快算机应用、计算机网络、电子商务
1.
.;表示从这个目录下开始查找；
2. if语句后面不要加“；”号！
如下情况：若if ( i == stop) break中，加了分号(即
25.如果将一个类打包，则使用该类时，必须使用该类的全名（例如：com.sxt.MyClass),Java编译器才会在找到该类。
26.访问权限：
private 类内部
default 类内部 同一个包
protected 类内部 同一个包 子类
public 类内部 同一个包 子类 任何地方
float=0.0F;double=0.0D;boolean=false;所以引用类型为null.
16.Java语言中除了基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的。
17.如下：C c1 = new C();
C c2 = new C();
则c1,c2为对象的引用。
【修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；……
}
例子：public static void main(String args[]) {
System.out.println("MENGDELEYUAN");
}
10 .int i = m4(4, 6);表示调用m4方法，即传给m4两个参数4和6，而m4方法返回什么样的值，这个表达式就是什么样的值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java常用关键字集合：extends：继承abstract：抽象interface：接口break：跳出循环case：分支continue：打断当前循环static：静态final：最终transient：非串行化synchronized：锁定native：本地方法throw：抛出自定义异常collection 集合常见异常：1、类造型异常2、空指针异常3、类型转换异常4、数组下标溢出异常5、传递不合法参数异常6、数值格式异常MVC：不改变程序功能，改变的是程序的架构V：视图：jspC：控制：web.xmlM:业务（逻辑）数据（持久层）：JDBCJSP常用内置对象：out request response session application PageContextDAY021、变量命名：规定：1）只能包含字母、数字、-、$，并且不能以数字开头2）严格区分大小写3）不能使用关键字4）2、变量的初始化：3、Java语法规定：变量在使用前必须初始化初始化两种方式：1）声明同时初始化int a=5;2)先声明再初始化int b; b=8;4、变量的使用：1）必须与数据类型匹配5、int：1）整形，占4个字节，范围从-21多亿到21个多亿2）两个整数相除，得到结果为整数6、long：long型直接量，在数字后面加L或l；Eg：long a = 35L;7、double：浮点数或小数小数的直接量默认为double型，若想表示float类型，则加F或f，double运算时会出现舍入误差。
8、char：1）char为字符型，占2个字节，直接量需放在单引号中，有且仅有一个。
2）char实际就是一整数，该整数就是字符对应的码。
9、boolean：布尔型，占一个字节，只能存储true和false。
常常用来表示关系或者逻辑结果。
10、基本类型间转换：1）自动类型转换：byte---shot---int---long---float---doublechar2）强制转换：从大类型到小类型但这样的转换有可能会造成数据源溢出和精度的损失。
11、1）整数直接量可以直接赋值给byte、char、short2）三者只要参与运算，则一律转为int型，,就是参与运算后就是int型了。
byte b1 = 2;byte b2 = 5;//规则1)byte b3 = (byte)(b1+b2);// 规则2)Day031、运算符：1）++、--单独使用在前在后无差别、使用时有差别，++在前先自增再使用，++在后先使用再自增，--同理。
2）算术3）关系：返回结果为boolean类型4）逻辑：建立在关系运算基础上，结果也是boolean类型与（&&）、或（||）、非（！）第一个数为false时&&短路第一个数为true时||短路5）赋值：建议使用扩展赋值a+=5；相当于a= a+5；6）+：两边都是数字做加法运算，有一边为字符串做连接7）三目：语法：boolean ？1 ：2运算过程中计算boolean为true则结果为1，为false则结果为2；2、分支结构If 1条路If...else 2条路if....else if 多条路switch 多条路——常常与break配合使用break：跳出switch优点：清晰、效率高缺点：只能是整形、只能判断相等，灵活性稍差3、ALT+/ 内容提示CTRL+303027495班级群Day 041、循环：一组相同或相似语句被有规律地重复性执行。
循环三要素：1）、循环变量初始化；2）、循环条件；（以循环变量为条件）3）、循环变量的改变；（向着循环结束变）注：循环变量：在循环过程中改变的哪个量2、Math.random()----生成0到1之间的（包含0，不包含1）----[0,1)3、continue：跳过循环体中剩余语句而进入下一次循环，应用率较低，常常可以用if、、、else代替4、break：终止循环：5、while和do，，while的区别：while是先判断后执行，有可能一次都不执行；do、、、while先执行一次再判断，至少执行一次；6、do{循环体}while(表达式)；注意：while后有分号Day 051、循环问题：1）、直到、、、、、的时候用do、、、while2）、当、、、、、的时候用while3）、固定次数循环用for嵌套循环执行过程，外层循环走一次，内层循环走所有次建议：循环层数越少越好break只能跳出一层循环2、程序= 算法+ 数据结构1）所谓数据结构，简单说就是把数据按照特定的某种结构来保存，设计合理的，数据结构是解决问题的前提，好的数据结构会引导出好的算法2）算法是解决问题的流程或步骤3）数组就是最基本的一种数据结构3、数组：1）、定义数据类型[] 数组名= new 数据类型[长度]；int[] arr = new int[4];2）、初始化int arr[] = new int[]{1,2,3,4,5};int arr[] = {2,5,4,7,6};3）、访问：通过下标、索引int len = arr.length;int num = arr[0];int num = arr[arr.length-1];arr[0] = 0;4）、复制：System.arraycopy(a,0,a1,2,5);从a的第一个元素开始，复制到a1，从第二个元素，共复制5个元素Arrays.copyOf(a,a.length);5）、排序Arrays.sort(arr);//升序冒泡Day061、方法是用于封装一段特定的逻辑功能，方法尽可能独立---只干一件事儿方法五要素：修饰词返回值类型方法名（参数列表）{方法体}// 方法都是用于操作数据的//如果所操作的数据比较固定-----不需要参数//如果所操作的数据不固定------需要参数Day071、类和对象的关系：类是用于构建对象的模板，对象是类的具体实例；2、面向过程编程：一堆方法，调来调去面向对象编程：以对象为核心，围绕着对象做操作面向接口编程：面向对象的基础上，接口复用性好、可维护性好、可扩展性好、移植性好、、、、3、所谓抽象数据类型：将不同类型的数据的集合组成个整体用来描述一种新的事物。
4、现实世界是由很多对象组成的，现实世界是现有对象，再抽出类、代码中先创建类在创建对象；一个类可以创建多个对象，同一个类的多个对象的结构相同，数据不同5、创建对象语法;类名引用名= new 类名（）；6、类是一种数据类型只能包含：1）、对象所共有的特征：属性-------静态的2）、对象所共有的行为：行为-------动态的类中除了定义成员变量，还可以定义方法，用于描述对象的行为，封装对象的功能7、成员变量用于描述该类型对象的数据结构，成员变量的位置放在类里面方法的外面。
8、基本类型之间的等号--------在赋值----（比如身份证复印件）引用类型之间的等号--------指向同一个对象9、new后，成员变量有默认值Day081、方法的签名包含：方法名和参数列表；一个类中，不能有两个方法的签名完全相同。
2、方法的重载与修饰符和返回类型无关，只与方法签名有关；3、在一个类中，方法名相同，参数列表不同，就称为方法的重载；4、编译器在编译时，根据签名调用不同方法；5、构造方法：1）、构造方法常常用于给成员变量初始化；2）、与类同名，没有返回值类型；3）、构造方法是在创建对象时被自动调用；4）、若自己不写构造方法，则编译器默认给一个无参构造，若自己写了，则不再默认提供无参构造；5）、构造方法可以重载；6、this：1）、this指代当前对象，哪个对象调就指向它；2）、用法：this.成员变量this.方法()；this.()----调构造方法7、引用类型数组的定义：Cell[] cs = new Cell[4];引用类型数组的初始化：1）、Cell[] cells = new Cell[4];cells[0] = new Cell();Cells[1] = new Cell(2,3);8、数组是引用类型，数组对象储存在堆中；9、数组的类型可以是基本类型数组，也可以是引用类型数组，引用类型数组new后，每一个元素默认初始值为null，Day091、堆中装的是new出来的对象（包括成员变量）2、成员变量声明周期：创建对象时存在，对象被回收时消失；3、垃圾回收器（gc）不定时回收，没有引用指向的对象，回收过程透明即不可见，想快些调用gc方法可以调用System.gc（）；4、内存泄露：不再使用的对象未被及时回收，建议对象不用了及时引用为null；5、Java中，调用一个方法，就给该方法分配一个“栈桢”，栈桢中存的就是局部变量，方法调用结束，栈桢消失，局部变量也跟着消失6、成员变量和局部变量的区别：局部变量：1）、定义在方法中；2）、没有默认值，必须自行设定初始值；3）、方法被调用时，存在栈中，方法调用结束，从栈中清除；成员变量：1）、定义在类中，方法外；2）、由系统设定默认初始值，可以不显示初始化；3）、所在类被实例化后，存在堆中，对象被回收时，成员变量失效；7、栈用于存储所有局部变量，调用方法时，栈中分配该方法的栈桢；栈桢中包括参数和局部变量，方法调用结束，栈桢被清除，成员变量失效；8、方法区：1）、存储类的信息（.class及方法）；2）、方法只有一份，通过this区分对象；9、继承：1）、避免代码重复；2）、通过extends关键字实现继承，子类继承父类后，将具有本类的成员以及父类的成员；3）、java里面是单一继承，一个父类可以有多个子类，一个类只能有一个父类；4）、构造子类之前必须先构造父类，如自己不写super，则在子类构造中默认添加super（），来调用父类无参构造；注意，super（）必须位于子类构造代码的第一句；10、向上造型：父类引用指向子类对象Day101、重写：发生在两个类中，并且是父子的关系，子类方法与父类方法签名相同时，子类重写了父类的方法；但是方法的实现不同；当子类对象的重写方法被调用时，运行的是子类的重写方法；可以通过super关键字调用父类的版本。
2、重载(overload)和重写(override)的区别：重载：在一个类中，方法名相同，参数列表不同，在编译时，根据参数的个数和类型来绑定调用方法；重写：发生在两个类中，并且是子类和父类的关系，两者签名相同（即方法名相同，参数列表相同）子类重写了父类，可以通过super来访问父类的方法；注意：（重载为编译期绑定，看类型，重写为运行期绑定，看对象）3、package：用于避免命名冲突，java建议每个类都写包名，类的全局限定名----包名+类名；4、import：用于引入类，访问不同包中类时需要import；5、访问修饰符：1)public共有的:任何类都可访问；2)protected受保护的:本类，子类，同包类可访问；3)默认:本类，同包类可访问；4)private私有的:只能本类访问；注意：类的修饰只能用默认的或public，类的成员上面四种都可以6、static ：s tatic关键字可以修饰成员变量，它所修饰的成员变量不属于对象的数据结构，而是属于类的变量，通常通过类名来引用static成员。