1.java的执行顺序

　　java（编译） Java（运行）

　　编写源码----------->字码文件----------->执行

2.编写源码注意

　　a.类名和文件名一致.

　　b.括号要成对出现.

3.println和print的区别

　　println会换行

　　print不会

4.转义字符

　　\n 表示换行

　　\t 表示空格

5.java注释

　　//：单行注释

　　/* */：表示多行注释

　　/** */表示文本注释

6.java代码规范

　　a.类名要用oublic修饰

　　b.一行只写一个语句

　　c.注意{}的位置

　　d.代码层次关系缩进（tab键）

变量，数据类型和运算符

2.1变量

　　变量：一个数据存储空间表示（代词）

2.2变量的基本语法

　　数据类型 变量名 //声明变量=变量值； //赋值

2.3变量的使用

　　a.变量必需声明，并且初始化够才能使用.

　　b.变量名不能重复.

2.4常见数据类型

　　int（整数）

　　double（双精度浮点数）

　　char（字符）

　　String（字符串）

补充：8种基本数据类型

　　byte （字节类型）

　　short （短整型）

　　char （字符型）

　　int （整型）

　　long （长整型）

　　float （单精度浮点型）

　　double （双精度浮点型）

　　boolean （布尔型）

2.5变量命名规则

　　变量名：由数字，字符，下划线，美元符号组成，

　　但是不能以数字开头

2.6赋值运算

　　变量名=表达式；

2.7算术运算符

　　+，-，*（乘），/（除取整），%（取余）

　　++，（自增）等价于 本身= 本身+1

　　--，（自减）等价于 本身= 本身-1

2.8类型转换

2.8.1分类

　　a.自动类型转换

　　b.强制类型转换

2.8.2自动类型转换

　　大类型 = 小类型

2.8.3强制类型转换

　　小类型 = （小类型）大类型

　　注意：强制类型转换是可能会出现溢出

2.9关系运算符

　　>（大于）,<（小于）

　　==（等于）, ！=（不等于）

　　>=（大于等于） <=（小于等于）

　　注意：==表示等于，= 表示：赋值

3.0 boolean类型

　　只有true和false两个值

3.1运算符运算优先级

　　（） > 算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算（=）

　　+，-... >， <... ||（或）&&（与）！（非）

选择结构

　　第一种：

　　　　if（条件）{

　　　　　　//代码块

　　　　}

　　解释：如果条件结果为true，那么执行代码块，否则不执行

　　第二种：

　　　　if（条件）{

　　　　　　//代码块1

　　　　}else{

　　　　　　//代码块2

　　　　}

　　解释：如果条件结果为true，那么执行代码块1，否则执行代码块2

　　第三种：

　　　　if（条件）{

　　　　　　//代码块1

　　　　}else if（条件2）{

　　　　　　//代码块2

　　　　}......{

　　　　　　...

　　　　}else{

　　　　　　//代码块n

　　　　}

　　解释：如果条件1结果为true，那么执行代码块1

　　　　　　如果条件1为false，那么将执行下一个条件

　　　　　　判断，依次重复上面的过程.

注意：

　　判断字符串是否相同用 str1.equals（str2）

　　判断数字相同用num1 == num2

2.switch...case 选择结构

　　switch（表达式值）{

　　　　case 值1：语句;break;

　　　　case 值2：语句;break;

　　　　.....

　　　　default：语句n；

　　}

　　解释：如果表达式的值为值1，那么执行语句1，

　　　　如果表达式的值为值2，那么执行语句2，

　　　　........

　　　　如果表达式从上至下都没有找到匹配到值，那么执行default后面的语句n.

注意：　

　　　　1）.表达式值可是整型，字符型。jdk1.7以后可以是sting类型

　　　　2）.break：表示终止，表达式整个swtich语句结果.

　　　　3）.如果匹配到值，并且没有执行break，那么从匹配到那个值的语句

　　　　开始，下面的每一个语句都会执行，知道整个程序结束后者遇到break.

 循环结构

1.while循环

　　while（条件）{

　　　　//代码块

　　}

解释：如果条件的结构为true，那么执行代码块

当代码块执行完后，又会执行条件，

依次循环，知道结果为false，整个循环结束.

2.程序调试

　　第一步：设置断点（左键双击）

　　第二步：debug方式执行代码

　　第三步：逐条执行条码调试（f6）

　　第四步：检查代码（看变量值的变化）

注意：在右上角可以切换java视图和debug视图.

3.do...while循环

　　do{

　　　　//代码块

　　}while(条件){
　　　　//代码块

　　}　　

解释：先执行代码块，然后进行条件判断.

　　如果条件为true，那么继续执行代码块

　　依次循环，知道条件为false，整个循环结束.

注意：

　　变量的作用域：从变量声明开始到它所在代码块结束.

4.while和do....while区别

　　a.执行顺序不一样

　　b.do...while中的循环体至少会执行一次;

　　而while中的循环体在结果为false时，不会被执行.

5.for循环

语法：

　　for（初始化表达式；条件表达式；循环变量变化表达式）{

　　　　//循环体

　　}

初始化表达式：用于初始化循环变量值

条件表达式：如果为true则执行循环体，否则退出

循环变量表达式：用于循环变量的控制如i++..

执行顺序：

　　第一步：初始化表达式（只会执行一次）

　　第二步：条件表达式；如果为true则执行第三步，否则退出循环.

　　第三步：循环体

　　第四步：循环变量表达式，执行完之后，再执行第二步，依次循环.

注意：

　　for循环中三个表达式都可以省略.

　　如果第二个表达式没有写，那么它的结果为true.

数组

1.数组的声明定义

　　数组类型[] 变量名 = new 数据类型 [长度];

　　例：int [] ary = new int [5]；

2.取值，赋值.

　　取值：数组名[下标];

　　int a = ary [1];

　　赋值：变量 = 数组名[下标];

　　例：ary [1] = 10;

3.数组的遍历

　　数组的长度：数组名.length;

　　for（int i=0;i<数组名.length;i++）{

　　　　//数组名[i]：访问每个元素的值

　　}

4.数组常见的异常

　　ArrayIndexOutOfBoundsException     //数组下标越界

　　当访问数组的下标超过0~length-1时，就会出现以上错误.

注意：数组下标范围：0~length-1

5.数组的常用方法

　　Arrays.toString（数组名）;    //展示数组内容

　　Arrays.sort（数组名）;  //数组按升序排序

6.后序遍历

　　for{int i = ary.length-1; i>=0; i--

　　　　ary[i];

　　}

7.比较字符串的大小

　　如果a.compareToIgnoreCase（b）>0 为true 那么a大于b.

　　如果a.compareToIgnoreCase（b）<0 为true 那么a小于b.

　　如果a.compareToIgnoreCase（b）==0 为true 那么a等于b.

8.break和continue

　　continue：继续（表示结束本轮循环，进入下一个循环）

　　break：终止，结束（表示终止当前循环结构）

注意：多层循环，只会对直接的循环起作用

类和对象

1.对象和类

　　类是对象的抽象，对象是类的具体事例.

例：人是类，小明是对象.

2.创建对象

　　语法：类名 对象名 = new 类名（）；

例：Person p = new Person();

注意：类名也是数据类型.语法也可以写成.

　　数据类型 变量名 = new 数据类型（）；

3.类的语法

　　public class 类名 {

　　　　//属性 --->特征

　　　　//方法 --->行为

　　}

4.定义属性

　　class 类{

　　　　//属性的数据类型 属性名;

　　　　例：int age；//表示年龄

　　}

　　属性的访问: 对象名.属性名;

　　属性的赋值：对象名.属性名 = 值;

5.方法的访问：

　　对象名.方法名（）;

无参方法

1.方法的定义

　　public 返回值 方法名（）{

　　　　//方法体

　　}

注意：

　　如果没有返回值，那么返回值类型是void.

　　如果有返回值，那么必须用return 返回值，并且该值的数据类型必须是定义方法

　　时的数据类型.

　　return的作用：

　　　　a.返回值

　　　　b.结束方法.（与break类似）

2.写方法时注意

　　第一点：定义void为返回值类型时，不能使用return+返回值.

　　第二点：方法不能返回多个值.

　　第三点：方法不能嵌套.

　　第四点：不能在方法外部直接写程序逻辑代码.

3.成员变量和局部变量的区别

　　a.作用域不同

　　　　局部变量的作用域仅限于定义它的方法

　　　　成员变量的作用域在整个类内部都是可见的

　　b.初始值不同

　　　　java会给成员变量一个初始值

　　　　java不会给局部变量赋予初始值

注意：

　　a.相同的方法中，局部变量名不能重复

　　b.不同方法中，局部变量名可以重复

　　c.同一个类中，成员变量名和局部变量可以相同，一般以局部变量为准.（就近原则）

4.java.lang.NullpointerException(空指针异常)

　　原因：对象的值为null，并且对次对象进行了操作.

　　解决方案：找到次对象的数据来源，查看到new对象的代码

　　是否执行或是否编写，根据不同的原因去解决问题.

注意：　

　　写任何代码

　　第一点代码的执行过程.

　　第二点：值来自于哪里.

建议：

　　1.别先写代码，先写步骤.

　　2.不要关注实现细节

有参方法

1.方法的定义

　　public 返回值类型 方法名（参数类型1，参数名1，参数类型2，参数名2，.....参数类型n）{

　　　　//方法体

　　}

2.有参数的调用

　　a.如果同一个类中，方法可以直接调用.

　　b.如果不同的类，方法必须通过对象调用，

　　对象名.方法名（实参，实参2...）

注意：

　　1）实参的数据类型，参数的个数，参数的顺序要跟形象保持一致.

　　2）调用有返回值的方法，一般要接受返回值，并作出相应的处理.

3.包

　　a.包：文件夹（从src目录下开始算起）

　　　　例：oo.day01

　　b.包命名规范

　　　　包由小写字母组成，不能以圆点开头或结尾.

　　c.当使用不同包中的类时，必须用import将这个类导入到

　　指定的类中，（如果是同一个包中的类，不需要import，java会自动导入）.

4.字符串（String）的定义

　　String str = “内容”

　　String str = new String（）;　　//内容为null

　　String str = new String（“内容”）;

5.java.lang.*

　　字符串所在的包是java.lang.

注意：所有在java.lang包下的类，我们使用时，不需要import.

6.常用方法

　　str.length();　　//字符串的长度

　　str.indexOf(str1);　　//子串str1出现的下标.（从前往后找）.

　　str.lastIndexOf(str1);　　//子串str1出现的下标（从后往前找）.

　　str.substring(begin);　　//截取从下标begin开始到末尾的子串.

　　str.substring(begin，end);　　//截取从下标begin开始到下标end的子串.

　　str.trim();　　//去掉首尾空白

　　str.toLowerCase();　　//返回字符串的小写

　　str.toUpperCase();　　//返回字符串大写

7.从现实抽象出类的步骤

　　第一：找出分类（分析出类）

　　第二：找出类的特征（分析类的相关属性）

　　第三：找出类的行为（分析类的方法）

8.常量（经常出现的变量值）

　　语法：public static final 数据类型 变量名 = 变量值；

注意：

　　变量名的所有字母都大写，多个单词用下划线（_）分割.

例：public static final String SEX_MALE=“Q仔”；

常量的访问方式：

　　类名.常量名；

构造方法(特殊方法，用来创建对象 没写就会默认有构造方法)

1.语法：

　　public 类名 （参数列表）{

　　　　　　//方法体

　　}

2使用

　　类名 对象 new 构造方法名（参数）；

例： Dog d = new Dog（）；

3 构造方法的作用

　　a.创建对象.

　　b.初始化值（属性值）

4构造方法和普通方法的区别：

　　a.构造方法没有返回值类型（return....）

　　b.构造方法的方法名就是类名，普通方法可以任意取.

　　c.构造方法的调用：new 构造方法名（参数）

　　普通方法的调用：对象名.方法名（参数）

注意：当你没有写构造函数时，java会提供默认的无参构造函数.

例：

　　public Dog{

　　}

方法重载

1.方法重载：

　　方法名一样，参数列表不一样.

注意：重载与返回值类型和访问修饰符无关.

2.static和final

　　static：静态的

　　　　用static修饰的属性，直接可以类名.方法名访问

　　final：最终的

　　　　用final修饰的属性，它的值初始化后，不能再改变

注意：static不能再方法中修饰局部变量

补充：

　　后++，先把本身的值作为表达式的值，然后本身+1;

　　例：i++

　　前++，先本身加1，然后再把值作为表达式的值;

　　例：++i

　　后-- 先把本身的值作为表达式的值，然后本身-1;

　　例：i--

　　前-- 先本身-1，然后再把值作为表达式的值;

　　例：--i

封装

1.封装：隐藏类内部细节

2.封装 步骤：

　　第一步：将属性私有化.（private）

　　第二步：提供getter/setter方法（getXxxx（），setXxxx（））.

　　第三步：在getter/setter中加入控制语句.

3. this关键词

　　this：表示当前对象.

　　调用属性：this.属性名

　　调用方法：this.方法名（）；

　　this()：表示调用构造函数.

注意：this()，必需写在构造函数的第一行.

继承（extends）

1. 继承：遗传

2. 语法

　　public class 子类 extends 父类{

　　　　//代码块

　　}

例：public class Dog extends Pet {

　　　　//代码块

}

3. 继承的特点

　　a.子类可以继承父类的非私有的属性和方法

　　b.不能继承构造方法

　　c.继承默认权限修饰符的方法和属性，子类和父类必需在同一包中

4. super（父类）

　　super.属性名; //表示访问父类的属性

　　super.方法名(参数); //表示访问父类的方法

　　super(参数);//表示访问父类的构造函数；

注意：super()访问父类构造函数时，必需写在第一行;

抽象类（abstract）

1. 抽象类

　　语法：public abstract class 类名(){};

2. 抽象方法

　　语法：public abstract 返回值类型 方法名（参数列表）;

　　例：public abstract void print();

注意：抽象方法有abstract修饰，并且抽象方法没有方法体.

3. 抽象类和抽象方法的特点

　　a.都用abstract修饰

　　b.抽象方法没有方法体

　　c.抽象类不能实例化，并且继承必需重写抽象类中的所有抽象方法

注意：

　　1.抽象类中不一定有抽象方法

　　2.含有抽象类方法的类，一定是抽象类（接口）

重写

1. 重写就是子类重写定义父类的方法

2. 重写规则

　　a.方法名和参数列表相同.

　　b.修饰符访问权限子类和父类相同或者比父类大.

　　c.返回值类型子类和父类相同或者是父类的返回值类型的子类

　　d.异常跟父类相同或者范围更小

重写时：

　　子类的东西都要与父类保持一致

方法重写：

　　位置相同,方法名相同,参数列表相同,返回值相同或是其子类,访问修饰符不能比父类严格

方法重载：位置同类,方法名相同,参数列表不相同,返回值无关,访问修饰符无关

final

　　final修饰的类不能被继承

　　final修饰的方法不能重写

　　final修饰的属性不能被修改

多态

1. 多态含义：一个事物的多种形态

2. 多态的表现

　　行为（方法）多态：重写和重载.

　　引用多态（动态绑定）：编译时的类型和运行时不一致的这种现象叫做动态绑定.

　　例：父类 = 子类.

　　　　pet p = new Dog（）；

3.向上转型和向下转型

　　向上转型：父类 = 子类；

　　向下转型：子类 = （子类）父类；

　　例：Dog d = Dog（）p；

注意：java.lang.ClassCastException：类型转换异常.

　　　　父类的运行时类型跟要转成的子类的类型不一致

注意：引用多态存在继承关系

instanceof

　　语法：对象A instanceof 类型B；

　　判断对象A的类型是否是类型B，如果是就返回true，否则返回false.

　　例：d instanceof Dog

实现多态的两种形式

　　a.使用父类作为方法形参实现多态

　　　　public void play(Pet p){}

　　b.使用父类作为方法返回值实现多态

　　　　public Pet getPet(int type){}

接口

1. 语法

　　public interface 接口名 extends 接口1，接口2..{

　　　　　　//1.常量

　　　　　　//2.抽象方法

　　}

2.特点

　　a.用interface修饰

　　b.接口可以继承接口，多继承

　　c.接口内只能定义常量和抽象方法

　　d.接口不能实例化，但是可以作为子类的引用

　　e.实现接口的子类都必需实现它的所有抽象方法

foreach循环和...

　　... :形参里面出现，表示的是可变参数

　　foreach循环:

　　　　语法：for(int 下标 = 0;i < 数组的长度;i++){ 数组元素值 数组[i]}

　　　　语法：for(数组元素类型 数组的元素值：数组){}

异常

1.异常：程序执行过程中出现的影响程序正常运行的现象.

2.异常语法

　　try{

　　　　//代码块

　　}catch(异常类型 e){

　　　　//代码块

　　}catch（异常类型 2 e2）{

　　　　//代码块

　　}...{

　　　　//代码块

　　}finally{

　　　　//代码块

　　}

注意：

　　try：表示可能出现异常的代码块.

　　catch：抓取异常，并进行处理,可以抓取多个异常,

　　　　　　异常的范围要从小到大抓取,并且只会执行第一个匹配的异常类型.

　　finally：最终的，不管是否出现异常，finally中的代码块始终会执行.

　　　　　　除虚拟机停止(System.exit(1))这种情况外.

注意：

　　finally 和 return的执行顺序：

　　　　　　先执行return,把返回结果保存在返回结果区域，并没有返回，再执行finally,

　　　　　　最后,把保存在结果区域的结果返回给调用者.　　

3.throws声明异常

　　a.就是当前方法，不能解决这个异常的时候，必须把这个异常交给上一个调用者去处理.

　　b.语法

　　　　访问修饰符 返回值类型 方法名(参数列表)[throws 异常]{}

java异常体系

Throwable

　　 error: (出现不能通过的程序处理的错误)

　　Exception:可以同程序抓取或者抛出的错误.

　　检查异常（非运行时异常）:编译阶段会出现的异常

　　　　SqlException,

　　　　IOException,

　　　　ClassNotFoundException

　　非检查异常（运行时异常RunTimeE）

　　　　NullPointerException,

　　　　ArrayIndexOfBoundsException,

　　　　ClassCastException,

注意：

　　checked异常，是必需处理的

　　运行时异常，可以不处理

导入第三方jar包

　　第一步：右击工程名，新建一个文件夹（Fold），名字为lib.

　　第二步：把第三方jar包复制到lib目录下.

　　第三步：右击工程名---->properties

　　　　　　---->java build path

　　　　　　---->libraries

　　　　　　---->add jar

　　　　　　---->再从项目的lib目录下选中你要的jar包

　　　　　　---->确定.

使用log4j

　　第一步：导入log4j jar包

　　第二步：写配置文件

注意：

　　文件名和文件路径

　　（开发）（生成）

　　log4j.rootLogger=debug | info

　　第三步:使用log4j

　　a.导入log4j类

　　　　import org.apache.log4j.Logger；

　　b.在指定类中，写属性

　　private static Logger logger = Logger.getLogger(指定类名.class);

　　c.在指定行写日志

　　logger.debug("日志信息");

　　logger.info("信息");

集合框架

　　Collection Map

　　List Set HashMap

　　ArrayList LinkedList HashSet

1. List的方法

　　List<元素类型> list = new LinkedList<元素类型>();

　　list.add(元素);　　//增加元素

　　list.add(index，元素);　　//向指定位置插入元素

　　list.remove(下标);　　//删除指定下标的元素

　　list.remove(元素);　　//删除指定元素

　　list.get(index);　　//获取指定下标元素

　　list.contains(元素);　　//集合中是否包含指定元素

2. Collection，List，Set的区别

　　Collection:不唯一，无序

　　List：不唯一，有序

　　Set：唯一，无序

3 .ArrayList和LinkedList的区别

　　a.都实现了List

　　b.ArrayList是可边长数组方式实现，查询效率高.

　　　　LinkedList是链表方式实现，增加和删除效率高.

4. List常用方法

　　List <Object> list = new ArrayList<Object>();

　　list.add(Obj);　　//增加元素

　　list.get(下标);　　//获取指定下标元素

　　list.size();　　　　//长度

　　list.remove(Obj);　　//删除指定元素

　　list.contains(Obj);　　//是否包含指定元素

5 .Map 常用方法（键值对方式存储数据）

　　Map<Object,Object> maps = new HashMap<Object,Object>();

　　maps.put(key,value);　　//增加元素

　　maps.get(key);　　//获取指定key的值

　　maps.size();　　//长度

　　maps.remove(key);　　//删除指定元素

　　maps.containsKey(key);　　//是否包含指定key

注意：

　　key是唯一的，如果重复那么后面的会覆盖前面的.

　　value是可以重复的.

6. Vector和ArrayList的异同

　　实现原理、功能相同、可以互用

　　Vector线程安全，ArrayList重速度轻安全，线程非安全

　　长度需增长时，Vector默认增长一倍，ArrayList增长50%

　　Hashtable和HashMap的异同

　　Hashtable继承Dictionary类，HashMap实现Map接口

　　Hashtable线程安全，HashMap线程非安全

　　Hashtable不允许null值，HashMap允许null值

初识JAVA