第一章：开发简单Java应用程序
1、 计算机程序：一组有序指令的集合
2、Java语言分为3个领域：
javaSE是Java技术核心（指桌面应用程序）：QQ、百度云…
javaEE是企业标准（面向Internet的应用程序）：京东、淘宝….
javaME(移动设备、小型嵌入开发)：手机上的软件
3、 三步骤：
编写源程序（程序以.java结尾）
编译（使用javac指令编译源程序 ，编译后的文件 以.class结尾）
运行（使用java指令运行编译后的文件）
4、 使用Myeclipse开发java程序步骤：
1）创建项目
2）编写源代码
3）编译
4） 运行
5、 外层框架
Public class 类名{
}
注意：类名和文件一致
6、 内层框架
Public static void main (String[] args) {
}
注意：方法名必须是main
主方法四要素：public static void String[] args
7、 输出指令
System.out.println(“女”);
System.out.println(“18’);
注意：System首字母大写，
Println和print区别：println输出后换行；print只输出不换行
（建议用Println）
8、\n和\t
（1）\n换行；
（2）\t制表位，4个字符作为一个单位
9、注释：
1）// 单行注释 以//开始到行末结束
2）/**
*
*/文本注释
3）\*……*\ 多行注释 多行用于注释代码块
10、java相关的技术：
Javascript jquery mysql 前台
jsp servlet hibernet spring struts2后台
orcale ……数据库
第二章：变量、数据类型和运算符
1、变量：存储数据的一个基本单元。
2、变量的声明和赋值：
1）声明并赋值：数据类型 变量名=值; 例：int price=1000;
2）声明、赋值分两步：数据类型 变量名; 例： int price;
变量名=值; price=1000;
3、数据类型2种：
（1）基本数据类型8种：
1）byte 长度：-128~127（-2的7次方到2的7次方减1）
2）short -2的15次方到2的15次方减1
3） int -2的31次方到2的31次方减1
4） long -2的63次方到2的63次方减1 99l
5）foat 99f
6）double 双精度double price=32.5;
7）boolean 真（true） 假（false） bolean isBrand=true
8）char 一个字符 ，两个字节 范围0~65535 参照ASCII字符编码表 char sex=’男’; char num=65;(输出A)
（2）引用数据类型：
1）String 字符串 例： String name=”张三”;
2）类
3）接口
4）数组
4、变量命名规范：
（1）英文单词或拼音
（2）首字母：以字母、下划线、$开头；
（3）当多个单词组成的变量名：以驼峰式命名法取名，例：studentName
（4）变量名要起到见名知义的效果
5、赋值运算符：= 把右边的值赋给左边
6、算术运算符：+ - * / %(取余)
7、num++;//num=num+1;num+=1;
num--;//num=num-1;num-=1;
System.out.println(--num);//先计算再输出，（++num同理）
System.out.println(num--);//先输出再计算，（num++同理）
8、double avg=(90+99)/3.0 发生自动类型转换
自动类型转换的条件;
1) 类型兼容：(int和double都是数值型)
2) 目标类型大于源类型
9、强制类型转换：（数据类型）变量名 （数据类型）值
例：double num=5.5; int result=(int)num;
或者int result=(int)5.5;
第三章：运算符和条件结构
1、保存真或假，使用boolean 变量
boolean 有两个值：true真、false 假
2、从控制台接受输入信息，通过创建扫描器
Scanner input=new Scanner(System.in);
Int age=input.memtInt();//接受int类型
String name=input.next();//接受String类型
3、关系运算符
> 、< 、 >= 、 <= 、 == 、 !=
4、==和=的区别
==比较，=赋值
5、条件判断if
if(表达式){
语句
}//当表达式为true真时执行语句
6、运算符分为单目、双目、三目
单目：！ ++ --
双目：= + - * / % | || & && ==
三目：?://int sign=java>90?1:0;三目表达式
7、逻辑运算符
| 、 & 、 || 、 && 、 ！
优先级顺序：()>！>算术运算符>&&>||>赋值运算符=
多使用()控制优先级
8、if—else
if（表达式）{
语句1；
}else{
语句2；
}
当表达式为真，执行语句1 ；当表达式为假，执行语句2
9、多重if—else if—else
if(条件1){
语句1；
}else if(条件2){
语句2；
}else if（条件3）{
语句3；
}else{
语句4；
}
10、switch(表达式){
case 值1：
语句1；
Break;
case 值2：
语句2；
Break;
case 值3：
语句3；
Break;
default:
语句4；
Break;
}
jdk版本在1.7或者1.7以上，表达式是值可以是String类型；值不能相同；
break的作用是跳出switch结构。
11、多重if 结构和switch结构的使用场合：
多重if判断区间值，switch判断等值
第四章：循环结构（一）
1、while循环：
语法：while（循环条件）{
循环操作；
}
特点：先判断，在执行。
2、==：用于数字比较，比较的是地址；
.equals：用于字符串比较，比较的是字符；
（如：！anwer.equals(“y”)）
3、do while
语法：do{
循环操作；
}while(循环条件);
特点：先执行，再判断
4、while和do while的区别：
除了语法上不同外；
当条件不满足时：while一次都不执行；而do while至少会执行一次
5、调试方法：设置断点 、单步执行、 观察变量
6、调试步骤：
1）猜测出错位置，设置断点
2）单步运行
3）观察变量的值
4）发现问题
5）修正代码，重新运行
6）解决问题
第五章：循环结构（二）
1、for语法
for（1参数初始化；2条件；3参数叠加）{
//4循环操作
}
特点：先判断，再执行
顺序：1 2 4 3
2、break：改变程序的控制流，多用于循环中；结合条件结构和分支结构，跳出整个循环
Continue：只能用在循环中；跳过循环体剩下的语句去执行下一个循环，结束当前的循环，进行下一步循环
3、while、do-while、for的区别：
（1）while语法：while（循环条件）{循环操作}
特点：先判断再执行
（2）do-while:do{循环操作}while（循环条件）；
特点：先操作再执行
（3）for语法：for(参数初始化；条件；参数改变){循环体}
特点：先判断再执行
使用场景：确定循环次数
4、使用循环的步骤：
（1）确定循环条件和循环体
（2）套用语法
（3）检查能否正常退出
第六章：数组
1、数组：是一个变量，存储相同数据类型的一组数据。
2、数据优点：减少代码量，容易查找
3、数据的步骤：
（1）声明数据：例：int score[];或者int[] score;
（2）开辟空间：例：scores=new int[5];
（3）赋值：例：scores[0]=100;
（4）使用：例：scores[0]=scores[0]+20;//最终的结果是：scores[0]=120;
4、数组声明的三种方式：
（1）Int num []=new [4]{1,2,3,4};
（2）int [] num=new int[4]；
（3）int num []={1,2,3,4}
5、引用数组元素的方式：
数据名称[下标];
例：num[0];
6、值传递和引用传递的区别：
值传递：不同的变量会分配不同的存储空间；不同的变量会分配不同的存储空间。
引用传递：赋值是把原对象的引用传递给另一个引用；两个引用指向同一块内存空间。
7、二维数组：
语法：数据类型[][]数组名=new 数据类型[一维数组的长度][二维数组的最大长度]；
数据类型 数组名[][]=new 数据类型[一维数组的长度][二维数组的最大长度];
例：int score[][]=new int[5][10];//int [][]score=new int[5][10]
结论：二维数组实际上是一个一维数组，它的每一个元素又是一个一维数组
8、赋值方式：scores={{1,5,8,9,10},{123,120}};
第七章：类和对象
1、对象的特征→指：类的属性 （每个对象的每个属性都有特定的值）
对象的操作→指：类的方法
2、封装
对象同时具有属性和方法两项特性。
对象的属性和方法通常被封装在一起，共同体现事物的特性，二者相辅相成，不能分割。
3、类和对象的区别：
类：是抽象的概念，仅仅是一个模子，确定了对象的属性和方法；
对象：能够看得见摸得着的实物，具有静态和动态特性。
4、定义类的步骤：
（1）定义类名
（2）定义类的属性：访问修饰符 属性类型 属性名称=默认值；
（3）定义类的方法：访问修饰符 返回值类型 方法名称（）{
方法体；
}
5、成员变量和局部变量：
成员变量：上级是类，作用域是整个类中
局部变量：上级是方法，作用域是当前的方法
6、类名命名规则：
（1）不能使用Java的关键字
（2）首字母可以是字母，也可以是_或$
（3）不能包含空格和标点符号
7、创建对象：关键字：new
类名 对象名=new 类名（）；
例：YuntuSchool Beijing=new YuntuSchool();
8、使用对象：关键符号：.
对象名.属性=值；例：beijing.schoolName=”云图智联北京中心”;
对象名.方法; 例：beijing.showInfo();
9、面向对象的优点：
（1）便于程序模拟现实世界中的实体；
（2）隐藏细节（封装）：对象的行为和属性被封装在类中，外界通过调用类的方法类获得，不需要关注内部细节如何实现。
（3）可重用
可以通过类的模板，创建多个类的对象。
10、类是引用数据类型：
在传值时，对象2=对象1传的是地址，一个改变，另一个也变；
对象2.name =对象1.name；传的是值，相互独立。
第八章：类的方法（一）
1、类的方法语法：
访问修饰符 返回值类型 方法名（）{
方法主体；
}
2、方法名的规范：
1.必须以字母、“_”或“$”开头
2.可以有数字，但不能以数字开头。
3.如果方法名是多个单词组成 ，第一个单词的首字母小写， 其后单词首字母单词大写。
4.方法名一般都采用动词。
3、方法的返回值
1.有返回值：必须告知返回值的数据类型，并且返回相应的值。
例：public String getName(){
return"张三"；
}
2.无返回值：void
例:public void showInfo(){
}
4、调用方法：
1. 不同类中：对象名.方法名（）；
2.同类中：方法名（）；
方法之间可以相互调用
5、变量声明的位置决定了方法的作用域
（1） 在方法中声明的变量叫做局部变量，作用域是当前的方法中。
（2）在类中声明的变量叫做成员变量，如属性，作用域是整个类中。
6、包的命名规范：
（1）包名由小写字母组成，不能以远点开头或结尾
（2）自己设定的包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名。如：域名 javagroup.net
（3）自己设定的包名部分依据不同机构各自内部的规范不同而不同
7、包的命名方式：package
公司的网址倒过来写，后加上项目名称，再加上所属的文件夹名称。
com.zhaopin.ts.entity
com.zhaopin.ts.servlet
com.zhaopin.ts.dao
com.zhaopin.ts.dao.imp1
com.zhaopin.ts.biz
com.zhaopin.ts.biz.imp1
8、doc注释：多用于注释类的信息
/** 开始
*/结束
第九章：类的方法（二）
1、带参的语法：
访问修饰符 返回值类型 方法名称（参数列表）{
方法体；
}
例：public String getFuirt(String fuirt){
String zhi=fuirt+m+"汁";
return zhi;
}
2、调用带参方法：
同类中， 非静态方法，方法名（参数列表）；
不同类中，对象.方法名（参数列表）；
3、带参方法的参数需要注意：
1.形参的数据类型和实参的数据类型一致。
2.方法形参的数量和调用方法实参的数量要一致。
第十章：字符串
1、 声明字符串的方法：（2种）
（1）String s=”您好”;
（2）String s=new String (你好);
2、 字符串是长度：
字符串.length();
3、 equals 比较的是值，一般用于字符串的比较；
== 比较的是地址，一般用于数字的比较。
4、字符串的方法比较：
（1）equlasIgnoreCase() 比较时忽略大小写
例：name.equlasIgnoreCase()
（2）toLoerCase()转换成小写
例：name. toLoerCase()
（3）toUpperCase()转换成大写
例：name. toUpperCase()
5、\叫转义符
6、拼接字符串：
用”+”或”concat()”方法，当原字符串是有效字符串时，在其后拼接新的字符串时，会创建副本。
例如：String str=”你好”;str=str+”北京”;
String str=new String(“你好”);str.concat(“北京”);
特点：使用”+”和”concat()”方法，会造成内存浪费，性能比较差，线程安全。
7、indexOf（参数）；获取字符或字符串的下标；
（1）indexOf（int ch）
例如：str.indexOf(’你’);
（2）indexOf(String s);
例如：str.indexOf(“.java”);
8、lastIndexOf(参数);获取最后一个字符或字符串的下标
（1）lastIndexOf(int ch);
例如： lastIndexOf(’你’);
（2）lastIndexOf (int ch);
例如： lastIndexOf(“.java”);
9、subString(参数);截取字符串
（1）subString(int index);
下标从0开始，从index开始截取到最后结束。
（2）subString(int beginIndex,int endIndex);
下标从0开始，从beginIdex开始截取，包括beginIdex位置，到endIdex结束，不包括endIndex位置。
10、trim()方法： 去掉字符串前后空格。
11、split()方法： 分割字符串 ，返回数组
例如：String st="长亭外-古道边-芳草碧连天-天外天-人外人";
String [] wor=st.split("-");
for (int i = 0; i < wor.length; i++) {
System.out.println(wor[i]);
}
12、StringBuffer类： 用于频繁拼接字符串时使用。
例如：StringBuffer sb=new StringBuffer(“你”);
Sb.append(“好吗？”);
Sb.insert(1.”们”)；
String word=sb.toString();
System.out.println(word);//你们好吗？
特点：在自身上追加字符串，不会产生副本，所以节省内存，性能高，线程安全。
13、String Builder类： 用于频繁拼接字符串时使用。在自身上追加字符串，不会产生副本，所以节省内存，性能高，线程不安全。
14、String 、StringBuffer、String Builder三者间的区别：
1） 原理：
String 频繁拼接时产生大量对象（副本），
StringBuffer 和String Builder 都是在当前对象上操作，所以不会产生大量对象（副本）；
2） 性能：
String< StringBuffer< String Builder
3） 线程：
String 和StringBuffer安全，String Builder非安全。
15、小结：
if(操作的数据较少){
String
}else {
If(多线程){
StringBuffer
}else{
String Builder
}
}
第十一章：抽象和封装
1、面向对象设计和开发程序的好处：
（1）交流更加流畅
（2）提高设计和开发效率
2、从现实中抽象出类分三步：
（1） 找出它的种类————（类名）
（2） 找出它的属性————（字段的名称）
（3）找出它的行为————（方法名）
3、抽象的原则：
（1）根据面向对象的思想抽象出类。
4、类图的好处：
（1）直观
（2）容易理解
5、构造方法：
（1）系统默认的无參构造：
例如：public Dog(){}
注意：当程序写了自定义构造方法时，系统自带的无參构造将消失。
（2）自定义的无參和有參构造：
a.自定义无參构造：
例如：public Dog(){
this.name=”大黄”;
this .love=100;
}
b. 自定义的有參构造：
例如：public Dog(String name,int love){
this.name=”大黄”;
this .love=100;
}
特点：a.访问修饰符是public
b．无返回值
c.构造函数方法名和类名一致
语法：
访问修饰符 函数名称 ([参数列表]){
[方法体;]
}//[]代表可以省略（不写）
5、this的含义：当前对象的引用。
this的使用：
this.属性
this.方法
this()构造函数：
例如：this();调用了无參构造
this.(参数1[参数列表]);调用了有參构造
6、static 静态的，可以修饰属性、方法、代码块。
被static 修饰过的属性、方法的调用方法：
类名.属性
类名.方法
被修饰过的代码块：类加载时，就加载代码块。
注意：方法里的变量不能被static修饰。
7、Final 最终的，可修饰属性，被修饰后叫常量。常量的是不可以被修改的。
常量的命名方式全部大写。
8、在开发中，一般一个完整的实体类包括：
（1）私有化的属性
（2）创建getter setter 方法[有參/无參]
（3）给getter setter方法添加控制语句
（4）创建[有參/无参]构造方法
第十二章：继承
1、使用继承：
1）方便修改代码
2）减少代码量
2、super 继承object 类：
super 访问父类的无参构造；super 指的是object 的无参构造。
例：子类调用父类：super.属性 / super.方法
注意：子类不能继承父类私有属性；得用set、get方法来调用；
super只能写在代码块的第一句；super只能调用非私有的方法；
super只能出现在子类的方法和构造方法中。
3、不能被继承的父类成员：
private成员、子类与父类不在同包，使用默认访问权限成员，构造方法。
| 访问修饰符 |
本类 |
同包 |
子类 |
其他 |
| Private |
√ |
|
|
|
| 默认（friendly） |
√ |
√ |
|
|
| Protected（受保护的） |
√ |
√ |
√ |
|
| Public |
√ |
√ |
√ |
√
|
4、继承：先执行父类的构造，在执行子类的构造。
顺序：父类属性 →父类构造方法→ 子类属性 → 子类构造方法
（符合is_a的关系就可以使用继承）
5、方法重载与方法重写：
|
|
位置 |
方法名 |
参数表 |
返回值 |
访问修饰符 |
| 方法重载 |
同类 |
相同 |
不相同 |
无关 |
无关 |
| 方法重写 |
子类 |
相同 |
相同 |
相同或是其子类 |
不能比父类更严格 |
6、多重继承关系的初始化顺序：
父类属性 → 父类构造 → 子类构造
7、当父类不需要实例化时，把父类声明为抽象类；
例：public abstract class 类名（）{}
8、当子类必须重写父类方法时，可以把父类的方法声明抽象方法。
抽象方法要求：
（1）抽象方法没有方法体
（2）抽象方法必须在类中
（3）加final(最终)不需要被赋值