认识java

1.java是一种编程语言，机器语言：010101010；汇编语言：通过大量的英文单词代表的计算机指令add 1 1;高级计算机语言：C/C++/C#/Java/Python/JavaScript/PHP
2.计算机由硬件（CPU、内存、硬盘等）和软件（操作系统、应用软件）组成。软件就是按照一定顺序组织起来的计算机指令与数据的集合。
系统软件：使计算机硬件具备基本功能；应用软件：必须在系统软件的基础上才能使用。
3.1999年分为J2SE 、J2EE、J2ME，其中04年1.5版本更名为JavaSE5.0，05年JAVA正式更名为JavaEE（企业版）、JavaSE（标准版）、JavaME（小型版）
4.JDK（java developement kit）--java开发工具包：是java程序运行的基础环境，包括JRE、一堆java工具、java基础的类库（rt.jar）
5.系统环境变量：在操作系统中定义的的变量，可供操作系统上的所有应用程序使用
6.IDE（integrated developement environment）集成开发环境：用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等
常用IDE：eclipse、myeclipse、intellij idea、netbeans ide。
7.新建项目->定义类（包名全小写，类名如FirstTest）->编写类源程序（记得保存）
8.注释：单行（ctrl+/）、多行、文档注释（ctrl+shift+/）
9.java程序结构：
代码编写：第一层定义类，它是最基本的组件，包含程序所需的所有属性和方法，注意类名和文件名一致；
第二层定义方法：主方法（public static void main(String[] args){ 多行程序代码 }）大括号包含多行代码；
第三层是执行代码：每行代码必须用英文的分号结尾
10.记事本开发java程序：编写java源程序（后缀名为.java）->编译源代码（javac hellowolrd.java后生成.class文件）->运行程序（java hellowolrd）->在dos窗口生成结果
11.java程序运行原理：使用虚拟机实现跨平台，java编译器把源程序编译为一种与体系结构无关的中间文件格式；
半编译半解释：源程序先被成功编译成字节码（出现错误称为编译错误），java解释器（运行系统）能直接对java字节码进行解释执行（出错车称为运行时错误）。

变量和运算符

1.关键字：是对编译器有特殊意义的单词，显示为红色，不同关键字来表示不同的数据类型或者结构；
保留字：goto，目前没有使用，以后是否使用未定；
标识符：包、类、方法、参数、变量统称为标识符，
命名规则：必须字母、下划线、美元符号开头，剩下的可以包括数字；
命名规范：类名使用pascal规则如：StudentDemo；变量名和方法名使用camel规则如：avgValue；包名全部小写如com.neusoft，常量名全部大写如：MAX_VALUE，public static final int PI=3.1415926;
2.常量：在程序中持续不变的值，必须指明数据类型
3.变量：指程序运行过程中随时可以发生变化的量；可以用来存放用户输入的数据、特定的运算结果。变量声明：如int x = 3;
数据类型：4类8中基本类型（primitive）：整型（byte（1个字节）、short（2个字节）、int（4个字节默认）、long（8个字节））、浮点型（float（4个字节）、double（8个字节默认））、字符型（2个字节char如‘A’）、布尔型（boolean，分为true和false）；引用类型（reference）：数组（array）、类class（String）、接口（interface）
4.转义字符:使用\把其转化成字符的本身输出
5.运算符：也称操作符，用以表示数据的运算、赋值和比较，种类分为赋值（=、+=、-=、=、/=、%=）、算术（+、-、、/、%、++（自增如++a：变量先自增再参与运算，a++：变量先参与运算再自增）、--（自减））、比较运算符（也称为比较运算符如：>、< 、>=、 <= 、==、!=、instance of ）、逻辑（存在短路现象如：!、&&、||）、位运算、条件运算（如z=x>y?x:y）
运算符优先级:括号最优先；一元操作符>二元操作符>三元操作符；算术>关系>逻辑>赋值
6.类型转换：
-自动类型转换：隐式类型转换，有多种数据类型混合运算时，系统自动将所有的数据转换为容量最大的那一种数据类型，然后计算。
转换规则：byte\short\char之间不会相互转换，首先转换为int->long->float->double
-强制类型转换：显示类型转换，容量大的数据类型转换为容量小的类型，需要使用强制转换。格式：int a=(int)7.9L;

流程控制语句

1.if条件语句：if(表达式){ 执行语句}；if(表达式){执行语句1 }else{执行语句2 }；if(表达式1){执行语句1}else if(表达式2){执行语句2}...表达式如果有多个条件，可以用逻辑运算符连接如：&&、||；
2.变量作用域：初始化定义后，在作用域里（使用一对大括号包含的语句范围）定义的变量，只能在该作用域中使用；变量名不可以重复定义。
3.switch语句：
switch(表达式)：{case 取值1: 语块1；break；case 取值n：语句n； break； default：语句n+1；}其中case不加缩进，case里面的语句要有缩进。表达式里可以接受int、byte、char、short、String（1.7版本及以后有效）；case 后面的取值（必须为常量）数据类型和switch表达式中的值具有相同类型。遇到break跳出或者结束switch语句的大括号。
4.字符串（String）类型：如"字符串"，通过String来声明字符串变量，属于引用类型中的类。
5.控制台输入：需要加包（import java.util.Scanner;）必须在package下一行；
new Scanner(System.in).nextInt();得到用户输入的整数；
new Scanner(System.in).nextDouble();得到用户输入的浮点数；
new Scanner(System.in).next();:得到用户输入的字符串，空格结束；
new Scanner(System.in).nextLine();:得到用户输入的字符串，换行结束。
6.产生随机数：需要加包（import java.util.Random;）， 代码：
new Random().nextInt(正整数);这个数代表随机数的范围
7.循环语句：while(循环表达式){执行语句}、do{执行语句}while(循环表达式);、for(int i=0;i<=100;i++){执行语句...}、增强型for循环：for(数组元素类型 变量名： 数组名){语句；};
8.循环的中断：break（终止某个语句块的执行。用在循环语句体中，可以强行退出循环）；continue（用于终止某次循环过程，跳过循环体中continue语句后面的未执行语句，重新开始下一次循环）
9.流程嵌套： 循环嵌套（9x9乘法表）、嵌套条件、循环和条件嵌套使用
10.死循环：靠自身控制无法终止的程序。while(true){语法块},for循环中的
循环判断条件省略，如：for(int i=0;;i++){语法块};或者for循环里面都省略，如：for(;;){语法块}；while循环里面的判断条件为true。
11.break label中断：格式：标签名：循环体{break 标签名；}其中标签名可以为任意标识符，循环体的标签名和break标签名必须对应一致 。

数组

1.数组可以看成是多个相同类型数据的集合，实现对这些数据的统一管理。数组元素（element）：数组中的每一个元素，可以为任意数据类型，包括基本数据类型（byte,short,int,long,float,double,char,boolean,数组,类,接口），元素的个数称为数组的长度（length）。
2.数组声明时不可以指定数组长度，int[] a;，指定数组的长度：int[] a=new int[4];长度一旦定义，固定不变。
3.数组的内存模型：所有元素都在堆内存中，创建一个数组就是在堆中创建一个数组对象，立即拥有默认值（整形默认0，字符串String默认null，字符char默认0对应的字符就是空格，浮点型double，float默认0.0，布尔型boolean默认false），索引从0开始，内存连续分配。
4.数组的初始化：如int[] a=new int[]{1,2,3}；或者int[] a={1,2,3}；
5.数组赋值：数组名[元素下标]=元素值；
6.创建数组：使用关键字new的初始化，称为动态初始化；在声明数组的同时
就是完成创建和初始化工作，这叫静态初始化。
7.数组长度:如：数组有length属性，用来显示本数组的长度。语法:数组名.length；长度必须>0；
8.一维数组：注意数组越界异常
9.多维数组：没有真正的数组，只有数组的数组。初始化如：int[][] a=new int[3][]；或者int[][] a={{1,2,3},{4,5},{6,7}}；；行的个数必须声明。
10.一维数组的应用:键盘输入班级学员的成绩，计算全班学员的平均分；找出最高的分。
11.二维数组的遍历：键盘输入的班级学员成绩，计算全班学员的每科的平均分。
12.冒泡排序（Bubble Sort）：重复地走访过要排序的数组，一次比较两个元素，如果他们的顺序错误就交换过来。走访数组的工作是重复地进行直到没有再需要交换，也就是该数组已经排序完成啦。
核心代码：for(int i=0;i<n;i++){for(int j=0;j<n-i;j++){if(a[j]>a[j+1]){int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}

方法声明和调用

1.方法的声明：方法是完成某个功能的一组语句，定义方法就是编写一段有特定功能的代码。注意：方法声明不能嵌套，也不能在类外声明
2.语法格式：[访问控制符] [修饰符] 返回值类型 方法名（参数类型 形参类型，参数类型 形参类型，...）{方法体}如：public static void main(String [] args){system.out.println("hello world");}
3.方法声明：大括号包含的语句块称为方法体，用于执行特定的功能操作。return关键字作用是结束方法执行，把方法的执行（运算）结果返回到方法外部。
4.修饰符：public 、protected 、default、private、static；返回值类型：用来说明该方法运算结果的类型，如果返回其他类型，编译就可能出错；
return 表达式 ：作用是将return后面表达式的结果作为方法的返回值。需要注意表达式的类型，必须与方法头中声明的“返回类型”相 匹配。
5.方法的分类：有参（基本数据类型和引用数据类型（数组，类，接口））和无参；有返回值类型和无法返回值类型（void）。
6.有参方法调用：实参直接在括号中，不需要类型声明。实参可以是常量，也可以是有值的变量。
7.方法中改变形参值：如果是基本数据类型是传入的一份数据的复制，方法中的改变不影响之前的实参；而如果是引用类型，传递的是地址值，所以在方法中改变的就是地址所指向的数据值。
8.方法注意问题:形参必须注明数据类型;实参直接写，不需要类型声明;return只能返回一次;遇到return语句，方法结束执行，后续语句不执行;方法的返回值必须与声明中的返回值类型匹配;方法定义，不能写在main()中;方法是不能嵌套的。
9.递归调用：一个方法体内调用它自身，这样的方法我们称之为方法递
归。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。注意：程序中要有递归的界限和递归范围的缩小
10.方法的重载：同一个类中允许同时存在一个以上同名的方法；要求：方法名一样；参数必须不同（参数类型或个数不一样；）；返回值类型无所谓

面向对象基础

1.传统c语言属于面向过程编程语言，面向过程的抽象是将实现一个功能的一组命令组合成为一个函数，问题：在对功能扩充时或者对于统一功能的不同实现，需要重写一个函数。
2.面向对象编程思想：从现实世界中客观存在的事物出发来构造软件系统，在系统构造中尽可能去运用人类的自然思维方式，强调直接以问题域中的事物为中心来思考问题、认识问题；并根据这些事物的本质特点，把它们抽象地表示为系统中的对象，作为系统的基本构成单位
3.面向对象编程：包括
OOA（object oriented analysis）：通常把构成问题域的事务分解为各个对象，给予对象相应的属性和行为，通过多个对象之间的相互协调来解决问题。建立对象的目的不是为了完成一个步骤，而是为了描述某个事务在整个解决问题的步骤中的行为、
OOD（object oriented design）：这些对象没有先后顺序，共同组成整个系统；只要用代码设计出这几个类型对象，让他们互相通信、传递消息就可以完成系统功能。
OOP（object oriented programming）：定义类名-》编写类的属性-》编写类的方法；
面向对象编程思想其实是一种运用对象、类、继承、封装、多态、聚合、关联、消息等概念来构造系统的软件开发方法。
4.面向对象的思想：分析系统涉及的事务中，根据对象抽取出类；根据共同的特点定义为属性，共有的行为定义为方法。
5.面向对象的概念：
抽象（abstract）:从事务中舍弃个别特征，抽取共有的本质特征，只考虑与系统问题相关的消息，忽略无关的部分。
对象（object）：系统中来描述客观事物的一个实体；可以有形可以无形（如客户或者银行卡）；对象构成一个独立单位；具有自己的静态结构（属性）和动态行为（方法）；每个对象都有自己唯一的标识。
类（class）：类是一组具有相同属性（变量）和行为（方法）的对象的抽象；类的作用是用来创建对象，对象是类的一个实例
类与对象的关系：抽象与具体的关系；类是对象生成的模板；一个类定义了使用哪些数据来描述属性，每一个对象都有相应的属性值数据，一个类通过一系列方法来定义行为，这些方法能在每个对象中被激活。
6.类的定义：格式如：[类访问修饰符] class 类名{类成员...}其中类成员包括：成员变量（属性）、成员方法（方法）、嵌套类（内部类）、代码块。编码规范：类名首字母大写；方法和属性的首字母小写，其他单词首字母大写。
7.局部变量和属性区别：方法中声明的变量、方法中的参数或者代码块中的声明的变量，都是局部变量。当属性和局部变量重名时，用this关键字来区分。
属性在任何地方都可以使用，而局部变量必须先声明再使用 。
8.类和对象的关系：类是创建对象的模板，对象是类的实例
9.对象的创建：是实际存在的某类事物的个体，也叫实例。创建语法：类名 对象变量=new 类名（）；或者是带参的构造方法。
10.对象的使用：在其他类中，使用对象名点运算符调用属性和方法。引用属性：对象名.属性；引用方法：对象名.方法（实参）。在类内的方法中，访问本类中的属性和方法可以直接访问。
11.创建对象原理：程序交由JVM来执行的，运行时数据区中包括这几部分：程序计时器、java栈（vm stack）、本地方法栈、方法区、堆。
实例化对象时，同时操作了栈内存和堆内存；栈内存中保存了基本数据类型的局部变量和对象的引用值；堆内存中保存了对象的属性和数组的元素。
对对象的所有的操作只能通过引用完成，一旦引用出栈释放没有任何引用指向该对象，对象就变成垃圾失效。
12.编写一个类的时候，不会占用内存；主函数中创建对象，运行主函数的类才能运行，只有在主函数中创建对象，才会占用内存。
13.对象属性分配在堆内存中，对象名称（也称为对象的引用，它是指java中的地址）分配在栈内存中；除了8种基本数据类型，其他变量都是引用数据类型如：数组（int[] a）、类(class Person)、接口（interface Run）
14.创建匿名对象：创建完对象，在调用该对象的属性或方法时，也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫匿名对象。如果只使用该对象进行一次方法或属性调用，可以创建匿名对象。
15.垃圾回收机制（Garbage Collection，GC）：当没有对象引用指向原先分配给对象的内存空间时，该内存就称为垃圾。JVM的一个系统级线程会自动释放该内存块。只作用于堆内存，与栈内存无关；JVM内部运行的一个优先级比较低的后台线程，自动进行垃圾回收。目的：避免忘记回收内存而引起的内存泄漏，同时也避免了回收内存带来的代码繁琐。
16.对象被回收的情况：对象引用被赋值为null；如：Person p=new Person(); p=null;；使用的匿名函数：如new Person().sayHello();；超过生命周期：如：for（int i=0；i<100；i++）{Person p=new Person }这里创建100个对象，循环赋值给变量p，每结束一次循环，变量p就超出生命周期，对象变为垃圾。
17.构造方法（constructor）:也是一种方法，所有对象都是通过构造器来创建的；创建对象语法：如类名 对象名=new 构造方法（）;；构造器特点：构造方法与列名必须相同，没有返回值和void，不能在方法中用return语句返回一个值。
18.构造方法作用：完成对象的实例化，每个类至少有一个构造器，可以不写出构造方法，编译器默认增加一个空构造器。编程者为该类定义了构造器，系统就不再提供默认的构造器。
17.构造方法重载：构造方法可以像普通方法一样发生重载，用户可以根据需要选择不同的构造器创建对象。一般可以使用构造器来完成对成员变量的初始化；最好还是养成写出这个无参数的构造器来，以备后用。
18.构造方法的调用：在其他类只能在创建对象时调用一次构造方法；普通方法可以在创建对象后，使用点运算符调用多次。
19.Java包的概念：包允许将类组合成较小的单元；有助于避免命名冲突；包允许在更广的范围内保护类、数据和方法。将类放入包中，语法为：package 包名 ;；
使用包注意问题：在java中位于包中的类，在文件系统中的存放位置，必须有与包名层次相对应的目录结构；package语句作为java源文件的第一条语句；每个源文件只能声明一个包；如果没有package语句，则默认为无名包；
Java类库中常用的包：java.lang：默认包，任何程序中，该包自动导入；java.io：输入输出操作有用的类的组成。
20.同包中的public类可以直接访问使用，访问不同包中的类，使用import关键字引入其它包中的类；必须在package声明后面，类声明前面；import语句可以出现多次。
21.package和import说明：包就像姓，类像名字；包与包之间的附属关系用"."来连接，就像复姓。
22.生活中的封装：将不想或不该告诉他人的东西隐藏起来，将可以告诉他人的内容公开（隐藏对象的属性和方法的实现细节，只公开对外接口）。
封装的好处：隐藏实现的细节、方便修改的实现、只能通过规定方法访问。
23.代码封装：
封装关键字：private（私有）；类的private成员只能被该类的成员访问；权限最小，让其他类不能直接访问属性，达到保护的目的。
default（默认）：不使用权限修饰符时(即default)的成员在类内以及在同一个包中的其他类可以访问。
protected（保护）：除了不同包下不同子类不可以使用，其他都可以。
public（公有） ：公有的，最高的访问级别， public成员可以在所有其他类中访问。
24.封装的常规使用：将类中的属性用private关键字进行隐藏；通过规定方法访问属性，一般通过set开头的共有方法对属性赋值，用get开头的共有方法得到属性的值；在方法中加入控制语句，对不合法数据进行检查。
25.静态关键字static：
修饰属性（静态变量或类变量，内存中存在一个副本，当且仅当类初始加载时会被初始化）被所有对象共享（直接访问：类名.属性）、
修饰方法（静态方法或者类方法）不需要实例化，可以直接访问（直接访问：类名.方法名()）；静态方法中不可以直接访问非静态属性和方法。
修饰语句块：类中由static关键字修饰的，不包含在任何方法体中的代码块，称为静态代码块。当类被载入时，且只被执行一次；静态块经常用来进行类属性的初始化。
26.单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点。
要点：只能有一个实例；必须自行创建这个实例；必须向整个系统提供这个实例。