程序是一系列有序指令的集合；
Java主要用于开发两类程序：
1）桌面应用程序
2）Internet应用程序
1，Java程序：三步走，编写--编译--运行；
2，使用记事本开发：
1）以.java为后缀名保存文件
2）使用javac命令编译.java文件，生成.class文件
3）使用java命令编译.class文件，输出结果
3，main（）方法是java程序的执行的入口点；
4，\n是换行符，\t是制表符
5，包资源管理器：
1）用包阻止Java源文件，类似于文件夹
2）选择菜单“Window-show view-package explorer”打开
src目录：存放包和源文件
JRE系统库目录：存放程序运行必须的系统库文件
6，导航器：
1）类似于windows中的资源管理器
2）选择菜单：“window->show view-navigator”
bin目录：存放可执行的字节码文件
src目录：存放java源文件
7，public修饰的类的名称必须与Java源文件同名!
System.out.println()和System.out.print()区别就在于一个换行，使用换行符\n可以是两者达到相同的效果
8，Java数据类型：
数值类型：整型（byte,short,int ,long），实型(float ,double),
非数值类型：char ,String
9，计算剩余的，就是利用%取余运算符
10，自动类型转换规则：
规则1：如果一个操作数为double型，则整个表达式可提升为double型
；
规则2：满足自动类型转换的条件
：
两种类型要兼容：
数值类型（整型和浮点型）互相兼容；
目标类型大于源类型：
例如：double 型大于 int 型；int可以转换成double，double不能转换成int；大可转成小，小不能转成大
10，优先级顺序：
算术运算符>关系运算符>逻辑运算符
运算符
赋值运算符（=）
；
算术运算符（+、 – 、*、/、%）；
关系运算符（>、<、>=、<=、 ==、 !=）；
11，数据类型转换包括自动类型转换和强制类型转换
12，if选择结构：是根据条件判断之后再做处理
if(条件) {： //条件必须是布尔值，
//代码块} //只有一条语句时，建议不省略大括号
多重if结构：当需要满足多个条件时使用，并且使用逻辑运算符
运算符优先级顺序：！>算术运算符>比较运算符>&&>||
13,产生随机数（0~9）的方法如下：
int random=(int)(Math.random()*10);
14,四位数分解获得百位：num/100%10
15,多重if选择结构中的最后一个else可以省略；
16，Java中的if选择结构，包括以下形式：
基本if选择结构：可以处理单一或组合条件的情况；
if-else选择结构：可以处理简单的条件分支情况；
多重if选择结构：可以处理分段的条件分支情况；
嵌套if选择结构：可以处理复杂的条件分支情况
；
0，循环由循环条件和循环操作组成
1，使用while循环时：
1）分析是否存在重复操作：
2）使用while循环实现：
确定循环条件和循环操作
套用while语法写出代码
检查循环是否能够退出
while循环：如果条件不成立，则一次都不执行操作
2，在编写程序时，会出现错误，但不好发现和定位错误，方法如下：
1）通过代码阅读或者加输出语句查找程序错误
2）当程序结构越来越复杂时，需要专门的技术来发现和定位错误，就是“程序调试”
程序调试的主要方法：
设置断点，单步执行，观察变量（F5单步跳入，F6单步跳过）
3，do-while：
特点：先执行再判断，while后面的分号不可少，
无论条件对错与否，其至少执行一次循环操作，
4，实现整数反转（回文）：
int val=12345;
int r_digit;
System.out.print(r_digit);
val=val/10;
5，循环次数固定的时候：for循环比while循环更简洁
6， Scanner s=new Scanner(System.in);
System.out.println("请输入商品编号："); //两句标准语句之间要加入表示请求的语句
int input=s.nextInt(); //注意与上一句的位置顺序，若写在上一句的上面，则不会有效果
7，continue的使用情况：
当循环条件不满足时（如for循环中），可利用到continue，结束本次循环，继续下次循环的判断
8，for循环：
for(参数初始化；条件判断；更新循环变量){}
9，加法表：
Scanner s=new Scanner(System.in);
System.out.println("请输入数字：");
int val=s.nextInt();
for(i=0,j=val;i<=val;i++,j--){
System.out.println(i+"+"+j+"="+(i+j));
}
s.close();
10，continue 作用：跳过循环体中剩余的语句而执行下一次循环
；
continue跳出本次循环，进入下一次循环
break语句作用：终止某个循环，程序跳转到循环块外的下一条语句；
使用场合：
break常用于switch结构和循环结构中
continue一般用于循环结构中
11，循环结构：
while，do-while，for循环
1，需要多次重复执行一个或多个任务的问题时，
考虑使用循环来解决问题
2，无论哪一种循环结构，都有4个必不可少的部分，初始部分，循环条件，循环体，迭代部分
适用情况：
循环次数确定的情况，通常选用for循环
循环次数不确定的情况，通常选用while或do-while循环
12，数组何时使用
？
当数据繁琐，不利于处理时，使用数组。
数组是一个变量，存储相同数据类型的一组数据。
声明一个变量就是在内存中划出一块合适的空间
声明一个数组就是在内存空间划出一串连续的空间
13，数组长度固定不变，避免数组越界
14，double和float的区别？？？
15，数组中的所有元素必须是相同类型。
16，使用数组的四步：
1，声明数组，int[] a
2，分配空间，a=new int[5]
3，赋值，a[0]=8
4，处理数据，a[0]=a[0]*8
17,数据类型[ ] 数组名 = new 数据类型[大小] ;
18,声明数组：
为节省时间：
方法一：
边声明边赋值：int []score={89,85,96};
或者int[] score=new int[]{89,79,96};
方法二：动态地从键盘录入信息并赋值
Scanner input=new Scanner(System.in);
for(int i=0;i<30;i++){
score[i]=input.nextInt();
}
数组是引用类型，数组名并不是数组元素的内容，而是一个引用地址，方法参数传递的是数组地址，根据这个地址可以找到内存中存放数组元素的连续存储区，通过“数组名[数组元素下标]”的方式来访问数组元素。由于数组名实际上是一个内存地址，如果一个方法的返回值类型是数组，方法体重返回结果时应使用“return 数组名”，而不能在数组名后加中括号，并且方法头定义中用“类型[]”指明方法的返回类型。
例如：
public class Array{
static String[] getArray(){ //返回一个字符串型数组，方法的返回类型是数组类型
String[] array={"123","sdf","45gfd"};
retrun array; //返回的是数组名
}
static void printArray(String[] data){ //注意参数是数组类型，因为要输出数组元素
for(int i=0;i<data.length;i++){
System.out.println(data[i]);
}
}
public static void main(String[] args){
String[] rtnArray=getArray();
printArray(rtnArray);
}
}
使用Scanner类时：import java.util.Scanner;
二重循环是一个循环体内又包含另一个完整的循环结构；
在二重循环中，外层循环变量变化一次，内层循环变量要从初始值到结束值变化一遍
；
在二重循环中可以使用break、continue语句控制程序的执行
在二重循环中使用continue:
for(int i=0;i<classnum;i++){
for(int j=0;j<score.length;j++){
if(score[j]<0){
continue; //若执行continue则只执行到此，直接执行j++，不执行count++了
}
count++;
}
}
在二重循环中使用break:
for(int i=0;i<5;i++){
System.out.println("欢迎光临第"+(i+1)+"家店");
for(int j=0;j<3;j++){
System.out.println("要离开吗（y/n）?");
choice=s.nextLine();
if(‘y‘==choice){
break; //执行break，跳出内层（for）循环，继续执行外层（for）循环语句；
}
System.out.println("买了一件衣服");
count++;
}
}
break：跳出本层循环，
continue：继续本层下一轮循环
for循环执行顺序：
for（1，参数初始化；2，条件判断；4，更新循环变量）{
3，执行循环体；
}
将字符d插入字符数组arr中：
char[] arr={‘a‘,‘b‘,‘c‘,‘e‘};
char ch=‘m‘;
int index=arr.length; //保存新增字符插入位置
for（int i=0;i<arr.length;i++）{ //比较元素得到插入位置
if(ch<arr[i]){
index=i;
break；
}
}
for(int j=arr.length;j>index;j--){ //index下标开始的数组元素后移一个位置
arr[j]=arr[j-1];
}
arr[index]=ch; //插入数据
打印等腰三角形，直角三角形，倒直角三角形：
等腰三角形设计时，需要借助空格来实现
int rows=0;
System.out.println("请输入三角形行数：");
Scanner s=new Scanner(System.in);
rows=s.nextInt();
for(int i=1;i<=rows;i++){
for(int j=1;j<=rows-i;j++){
System.out.print(" ");
}
for(int k=1;k<=rows*2-1;k++){
System.out.print("*");
}
System.out.print("\n");
}
直角三角形：
for（int i=1;i<=rows;i++）{
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.print(" ");
}
倒直角三角形：
for( int i =1 ;i<=rows;i++){
for(int j=1;j<=rows-i+1;j++){
System.out.print("*");
}
System.out.print("\n");
}
如下代码生成四位随机数：
int max = 9999;
int min = 1000;
cardNumber = (int)(Math.random()*(max-min)) +min;
注意equals函数的使用：
if (userName.equals(inputName) && password.equals(inputPassword))
Java中运算符有算术运算符、关系运算符和逻辑运算符等；
Java中的类型转换分自动类型转换和强制类型转换；
多重if和switch选择结构都可以用于多分支的情况，但使用场合不同；
while循环先判断再执行，do-while循环反之；
for循环适用于循环次数确定的情况
；
break和continue都可以改变程序执行的流程，但含义不同，使用场合也不同
；
类和对象：
当在类中声明成员变量时注意位置,在类里面（成员方法外面，也在主函数外面）声明成员变量：
import java.util.Scanner;
public class T{
Strin name;
int age;
public void show(){
Scanner input=new Scanner(System.in);
while(!"n".equals(name)){//除了字符n外的字符串等于name
if(age>=18 && age<=60){
System.out.println("20元");
}else{
System.out.println("免费"):
}
}
}
}
public class InitialVistor{
public static void main(String[[] args){
Scanner input=new Scanner();
Visitor v=new Visitor();
System.out.println("请输入姓名：");
v.name=input.next(); //注意是next即可
System.out.println("请输入年龄：");
v.age=input.nextInt();
v.show();
}
}
方法之间允许相互调用，不需要知道方法的具体实现，实现重用，提高效率 ：
Student类的方法a( )调用Student类的方法b( )，直接调用：public void a( ) {
b( ); //调用b( )
}
Student类的方法a( )调用Teacher类的方法b( )，先创建类对象，然后使用“.”调用 ：
public void a( ) {
Teacher t = new Teacher( );
t.b( ); //调用Teacher类的b()
}
return只有在方法类型不是void时才能使用；
return不能返回多个值：如return weight，height；//这是错误写法
方法不能嵌套定义（即方法里面定义方法）
不能在方法外部直接写程序逻辑代码！：
例如：
public class Student4 {
int age = 20;
if(age < 20) { //不能有这段代码
System.out.println("年龄不符合入学要求！"); //也不能有这段代码
}
//也不能有这段代码
public void showInfo() {
return "我是一名学生";
}
}
变量声明的位置决定变量作用域；局部变量则只能用在声明它的范围内，成员变量则可以用于该类的方法或其他类的方法；
变量作用域确定可在程序中按变量名访问该变量的区域
；
成员变量和局部变量的区别
：
作用域不同：
局部变量的作用域仅限于定义它的方法；
成员变量的作用域在整个类内部都是可见的
；
初始值不同
：
Java会给成员变量一个初始值；
Java不会给局部变量赋予初始值
；
在同一个方法中，不允许有同名局部变量
；
在不同的方法中，可以有同名局部变量
；
在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
；
JavaDoc注释：使用/**开始和*/结束，用来注释类，属性和方法等
/**
* AccpSchool类 //描述信息
*@author JadeBird
//@author：描述作者信息
*@version 1.0 2011/06/21 @version ：描述版本信息
*/
例：
/**
* ScoreCalc类 //类的JavaDoc注释
* @author 北大青鸟
* @version 2.0 2013/06/01
*/
public class ScoreCalc {
/** Java成绩 */ //属性的JavaDoc注释
int java;
//...
/**
* 计算总成绩 //方法的JavaDoc注释
* @return total
*/
public int calcTotalScore() {
int total = java + c + db;
return total;
}
//...
}
1，定义类的方法必须包括以下三个部分：
方法的名称，
方法返回值的类型，
方法的主体
，
2，类的方法调用，使用如下两种形式
：
同一个类中的方法，直接使用“方法名()”调用；
不同类的方法，首先创建对象，再使用
“对象名.方法名()”来调用
；
3，在Java中，有成员变量和局部变量，它们的作用域各不相同；
4，JavaDoc注释以“/**”开头，以“*/”结尾
；
面向对象思想：
类的方法实现某个特定的功能，其他类不需要知道它如何实现，调用方法就可以了，不用重复写代码
Java获取随机数的3种方法：
注意：Java中，对于带参数形式的非void类型方法，调用方法后，要记得对返回值进行处理
例：
public boolean searchName (int start,int end,String name) {
boolean find = false; // 是否找到标识
// 指定区间数组中，查找姓名
for(int i=start-1;i<end;i++) {
if(names[i].equals(name)) {
find=true;
break;
}
}
return find; //注意返回值的处理
}
数组作为参数的方法：
public double calAvg( int[] scores ){
int sum=0;
double avg=0.0;
for(int i =0;i<scores.length;i++){
sum+=scores[i];
}
avg=(double)sum/scores.length;
return avg;
}
对象作为参数的方法：
利用面向对象思想将多个参数封装成对象，将对象作为参数，这是更好的实现方式。
例：在实现了增加一个学生姓名的基础上，增加学生的学号、年龄和成绩，并显示这些信息，如何实现？
方式一：设计带四个参数（学号、姓名、年龄、成绩）的方法
。
方式二：将学生学号、姓名、年龄、成绩封装在学生对象中，设计方法，以学生对象作为参数
包命名规范
：
包名由小写字母组成，不能以圆点开头或结尾
；
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
；
包名后续部分依不同机构内部的规范不同而不同
；
总结：
带参方法定义的一般形式
：
<访问修饰符> 返回类型 <方法名>(<参数列表>) {
//方法的主体
}
形参是在定义方法时对参数的称呼；
实参是在调用方法时传递给方法的实际的值；
调用带参方法时要求实参与形参要匹配
；
创建包使用关键字package；
导入包使用关键字import
；
String类（字符串类）位移java.lang包中，
String类提供了length()方法，确定字符串的长度 ：
System.out.print("请输入密码： ");
pwd=input.next();
if( pwd.length()>=6 ){ //计算长度
System.out.print("注册成功！ ");
}else{
System.out.print("密码长度不能小于6位！");
}
String类提供了equals( )方法，比较存储在两个字符串对象的内容是否一致
：
System.out.print("请输入用户名： ");
uname=input.next();
System.out.print("请输入密码： ");
pwd=input.next();
if( uname.equals("TOM") && pwd.equals("1234567") ){
System.out.print("登录成功！ ");
}else{
System.out.print("用户名或密码不匹配，登录失败！");
}
“==”和equals()有什么区别呢？
==：判断两个字符串在内存中的首地址，即判断是否是同一个字符串对象；
equals（）：检查组成字符串内容的字符是否完全一致；
字符串连接：
方法一：使用“+”
方法二：使用String类的concat（）方法
字符串常用提取方法：
搜索第一个出现的字符ch（或字符串value）：返回出现第一个匹配的位置
如果没有找到字符或字符串，则返回-1
public int indexOf(int ch)
public int indexOf(String value)
搜索最后一个出现的字符ch（或字符串value）：返回出现第一个匹配的位置
如果没有找到字符或字符串，则返回-1
public int lastIndexOf(int ch)
public int lastIndexOf(String value)
------------------------------------------------
public String substring(int index)：提取从位置索引开始的字符串部分
public String substring(int beginindex, int endindex)：提取beginindex和endindex之间的字符串部分
//beginindex: 字符串的位置从0开始算；endindex: 字符串的位置从1开始算
public String trim() ：返回一个前后不含任何空格的调用字符串的副本
StringBuffer类:
StringBuffer：String增强版
对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率;
StringBuffer声明
:
StringBuffer sb = new StringBuffer(); //创建空的StringBuffer对象
StringBuffer sb = new StringBuffer("aaa");
//创建一个变量存储字符串aaa
StringBuffer的使用
：
sb.toString(); //转化为String类型
sb.append("**"); //追加字符串
sb.insert (1, "**"); //插入字符串，在1的位置插入
例：
StringBuffer sb = new StringBuffer("青春无悔");
int num=110;
StringBuffer sb1 = sb.append("我心永恒");
StringBuffer sb2 = sb1.append(‘啊‘);
System.out.println(sb2); //青春无悔我心永恒啊
StringBuffer sb3 = sb2.append(num);
System.out.println(sb3);
//青春无悔我心永恒啊110，此处相当于sb3.toString();
例：
从后往前插入：
输入一串数字，从后往前每3位插入一个逗号：
public class insertString {
public static void main(String[] args){
System.out.println("请输入一串数字：");
Scanner s=new Scanner(System.in);
String input =s .next();
StringBuffer str=new StringBuffer(input); //关键语句
for(int i=str.length()-3;i>0;i=i-3){ //关键语句
//注意从后往前，获取长度
str.insert(i,",");
}
System.out.print(str);
}
}
价格的格式化输出：从小数点往前数3位插入一个逗号
public StringBuffer change(double d){
StringBuffer str=new StringBuffer(String.valueOf(d));
for(int i=str.indexOf(".")-3;i>0;i=i-3){
str.insert(i,‘,‘);
}
return str;
}
总结：
String类提供了大量的操作字符串的方法
：
获得字符串的长度：length()；
比较字符串：equals()；
连接字符串：concat()；
提取字符串：substring()
；
搜索字符串：indexOf()
；
拆分字符串：split()
；
常用的StringBuffer类提供的方法
：
转换成String类型：toString()；
连接字符串：append()
；
插入字符串：insert()
大小写问题：
使用equalsIgnoreCase()方法：比较时不考虑大小写问题
使用toLowerCase()方法
：变成小写
使用toUpperCase( )方法
：变成大写
通过字符串长度确定数组：
例：输入一段字符串，确定要查找的字符，输出是否包含该字符
public class Count {
public int counter(String inputs,String word){
//注意此处数组利用 输入的字符串的长度来确定
String[] str=new String[inputs.length()];
int count=0;
for(int i=0;i<str.length;i++){
str[i]=inputs.substring(i,i+1); //注意此处i,i+1
}
for(int j=0;j<str.length;j++){
if(str[j].equals(word)){//注意equals的使用
count++;
}
}
return count;
}
添加元素：
for(int i = 0; i < dvd.name.length; i++){
if(dvd.name[i] == null){ //查询最后一个空位置插入
dvd.name[i]=input;
dvd.state[i]=1;//置新增的DVD可借状态
System.out.println("新增《"+input+"》成功！");
break;
}
}
删除元素：遍历数组，查找匹配信息，若找到，每个元素前移一位：
//遍历数组，查找匹配信息
for(int i = 0 ; i < dvd.name.length; i++){
//查找到，每个元素前移一位
if(dvd.name[i]!=null &&dvd.name[i].equalsIgnoreCase(name)&&dvd.state[i]==1){
int j=i;
while(dvd.name[j+1]!=null){
dvd.name[j]=dvd.name[j+1];
dvd.state[j]=dvd.state[j+1];
dvd.date[j]=dvd.date[j+1];
j++;
}
//最后一个不为空的元素置空
dvd.name[j]=null;
dvd.date[j]=null;
System.out.println("删除《"+input+"》成功！");
flag=true;//置位，表示删除成功
break;
}else if(dvd.name[i]!=null &&dvd.name[i].equalsIgnoreCase(name)&&dvd.state[i]==0){
System.out.println("《"+input+"》为借出状态，不能删除！");
flag=true;//置位
break;
}
}
不匹配：
if(dvd.name[i] == null){ //无匹配
System.out.println("没有找到匹配信息！");
break;
}
可利用类SimpleDateFormat对字符串进行日期格式化:
SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");
17，使用switch结构：特点：条件为等值判断，条件为整形或字符型；
default的顺序可以改变，但通常放在末尾，也可以省略，
18，switch和多重if的结构
相同：都用来处理多分枝条件的结构；
不同：
switch：只能处理等值条件判断的情况，而且条件必须为整形或字符行；
多重if结构：没有限制，特别适合某个变量处于某个连续区间的情况；
18，处理输入的数字异常：
Scanner对象的hasNextInt()方法，可以判断用户从键盘输入的字符是否是合法的数字
Scanner input = new Scanner(System.in);
if (input.hasNextInt()) {
//
}else{
System.out.println("请输入正确的数字！");
}