知识回顾：
1） 异常（业务异常，用户千奇百怪，有很多奇葩，不管代码怎么写的，他乱输入，对于这些特殊非法值，程序都应该能正常避过。）
a) try，可能错误代码放入try中，尽量无法代码不要放在里面
b) catch，捕获异常，如果try中代码出错，就会直接跳转到catch中执行，处理预先知道可能错误，进行异常处理，提升：“程序发生问题，请联系管理员”
c) exception，获取异常信息：e.getMessage()出错描述信息。
d) throw，抛出异常，自己处理不了，抛出给上级（调用类）
e) throws，接收异常，调用类就必须接收这些异常，要么自己处理try/catch，要么在抛出，它的调用类就必须处理。这些eclipse都有提示。
2） 流程控制
a) 顺序执行。从上到下，从左到右。注意赋值语句先执行=右边，把右边结果赋值左边。
b) 分支执行
i. 单分支：if(){}如果条件成立true，就执行里面的代码，否则不执行、if(){}else{}
ii. 多分支：if(){}else if()…else{}，switch(phone) case 110,break，switch语句可以用elseif替代
c) 循环执行
i. for，for(int i=0;i<10;i++){}，foreach后面开发中会学习到，对象变量
ii. while，可以改造成for，while更加灵活，在while前面初始化变量，注意，在while方法体内，必须改变判断值。i++，不做就死循环了。
iii. do-while，本质就是while，它们的区别。While的循环可能一次都不执行，do-while因为判断是在执行代码后面，所以不论条件是否成立，最少执行一次。（读取磁盘文件）
今天内容：
1） 面向对象
2） Java中最重要东西：类，对象（java万物皆对象）
3） 剖析类结构：类、成员变量、构造方法三要素
4） 方法重载
1） 面向对象，代码编程之前，设计（概要设计、详细设计、类设计），有不同思考方式
a) 面向过程，传统思考方式都是面向过程，做一件事，第一、第二、第三，侧重于整个业务完成过程。
b) 面向对象，新思考方式，业务中涉及哪些对象，对象有哪些属性和行为，侧重于业务中实体（对象）
举例：经典案例：把大象装入冰箱分几步？
a. 面向过程分析：（和我们日常思考方式一样）
第一， 找到一个大象
第二， 把冰箱门打开
第三， 把大象放入
第四， 把冰箱门关闭
b. 面向对象分析：
先找这个过程中涉及对象：（业务中名词）关注内容更加广泛，事先想的多，哪怕有些暂时用不到
大象（属性：几岁，体重，四肢，尾巴，眼睛。。。；行为（动作）：跑，走，吃。。。）
冰箱（属性：大小，几开门，冻到几点。。。；行为：插电，冷冻功能）
面向对象思考方式比面向过程思考方式多思考很多，抽象难度更大。
面向过程，c语句，vb，2004年接触java纯面向对象语言。
为什么编程主流设计思想：面向对象
开发中有一个无法避免问题，这个问题会造成项目延期，甚至无法交付，甚至软件黄了。
需求变更：做完用户不满意，说你做的不是他想要的？
a. 开始要求，把大象放入冰箱就可以了
b. 中间又提一个要求，大象多大？（面向过程重新修改代码）
c. 又提出一个要求，冰箱必须海尔（面向过程重新修改代码）
面向对象之前考虑非常多，用户的隐性需求都在我们的设计中涵盖，只要修改一点点代码，同时，不会对全局设计有影响。
结论：现在开发都以“面向对象”为核心开发方式。实际开发中其实很多地方都是“面向过程”。非常考验软件设计者的设计能力。一般企业中高级资深，系统分析师去做（8年+，很多年经验），对于初学者要求，这些名称，概念了解即可。
2） 面向对象OOP，Object Oriented Programming 面向对象编程语言
a) 封装
b) 继承
c) 多态
d) 抽象
3） Java中万物皆对象
a) 类
b) 对象
This method must return a result of type Integer
这个方法必须有返回值，返回值类型为Integer
Cannot make a static reference to the non-static method add2(Integer, Integer) from the type HelloWorld
Main是一个静态方法，它不能调用非静态add2方法
package cn.tedu;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
//静态方法调用 public static Integer add()
Integer r1 = HelloWorld.add1(10, 20);
System.out.println(r1);
//普通方法调用
//HelloWorld.add2(10,20);
//对应非静态方法，必须先创建对象，然后再调用
//helloWorld就称为对象
HelloWorld helloWorld = new HelloWorld();
Integer r2 = helloWorld.add2(10,20);
System.out.println(r2);
}
//创建一个方法，整数相加方法 z=x+y
//java中尽量用包装类型
//有两个参数
public static Integer add1(Integer x, Integer y) {
Integer z = x + y;
return z;
}
public Integer add2(Integer x, Integer y) {
Integer z = x + y;
return z;
}
}
规则：尽量不要使用static方法，它比较占资源
类：是蓝图，死的，不能直接调用类方法（add），只能有一个（盖房子图纸）
对象：实例，实际案例，具体内容，活的，就可以调用对象方法（add），一个类可以创建多个对象（具体楼，相同图纸可以盖好几栋楼）
HelloWorld helloWorld = new HelloWorld();
HelloWorld h1 = new HelloWorld();
最常见方式，通过new关键字创建新的对象，
4） 类的组成，三要素
a) 构造方法，用来创建对象时，设置初始化值
b) 成员变量（属性）
c) 普通方法（函数）
人类：
构造方法：如果你的类不写构造方法，java编译器会优化，它会自动创建默认构造方法。因为类必须有构造方法才能创建类，才能使用new关键字。
成员变量：name、age
普通方法：work()
package cn.tedu;
public class People {
//私有成员变量
private String name; //姓名
private Integer age; //年龄
//普通方法
public void work() {
System.out.println("我去工作了");
}
}
记住：包装类型的默认值是null，
有参构造方法比默认构造方法更加灵活，用户可以传入动态值。
package cn.tedu;
//私有成员变量，普通方法，默认构造方法，带参构造方法
public class People {
private String name;
private Integer age;
public void work() {
System.out.println(name+"开始工作了，他的年龄是："+age);
}
//默认构造方法：没有返回值，方法名字和类名一致，一个类中只能有一个默认构造方法
public People() {
name = "tony";
age = 18;
}
//带参构造
public People(String name, Integer age) {
//this就代表这个类
//成员变量和参数同名，此时成员变量可以通过this来明确区分
this.name = name;
this.age = age;
}
}
package cn.tedu;
public class TestPeople {
public static void main(String[] args) {
//调用默认构造方法
People p1 = new People();
p1.work();
//调用带参构造方法
People p2 = new People("任正非",60);
p2.work();
People p3 = new People("James Pond", 70);
p3.work();
}}
上午小结：
1） 面向对象和面向过程思考方式不同
a) 面向过程，关注是处理过程，第一、第二、第三。。。
b) 面向对象，关注是实体（语句中名词，大象，冰箱），成员变量（大小、体重、颜色。。。）和方法（走、跑、撒花。。。）
c) 不容易理解，要花很长时间。慢慢来
2） 类和对象 HelloWorld hw = new HelloWorld();
a) 类：HelloWorld，死的，不能直接访问成员变量和方法，蓝图（盖房子图纸）
b) 对象：hw（实例），活的，就访问成员变量和方法，具体实际东西（具体多个房子）
一般情况下对象都是new出来的。
3） 类由三部分组成
a) 私有成员变量，尽量使用包装类型
i. private String name
ii. private Integer age
b) 普通方法
c) 构造方法：
i. 无参默认构造 People p = new People();
ii. 有参构造（更加灵活）People p = new People(“任正非”, 60);
默认构造方法，无返回值，方法名必须和类名一致，一个类中只能有一个默认构造方法
自己可以不写默认构造方法，如果再没有其他的构造方法，java编译器优化时会自动加入默认构造。
问题：
1） 构造方法只需要掉一个，在写代码时new People()这就是调用默认构造方法，如果你没有写构造方法，java在编译时，生成.class文件时，会自动加入默认构造方法。调用时具体指定带参构造方法，默认构造方法就不需要执行。
2） 调用方法必须创建测试类吗？可以不用，通常可以在自己类中写main方法，也可以单独创建测试类进行测试。后者是好习惯。
3） 静态方法和普通方法区别。正课还要深入讲
a) 静态方法：HelloWorld.add();
b) 普通方法： HelloWorld hw = new HelloWorld(); hw.add();
4） Integer和int的区别
a) 在一个方法体中使用基本变量，基本类型没有额外方法，所占内存空间小。优点占用空间小，用完就被释放资源。缺点，就没有包装类型这些转换方法，很多需要自己写。开发麻烦。
b) 在一个类的成员变量尽量包装类型，也叫引用类型，对象，它有很多额外方法hashCode()，intValue()，toString()。。。，有了这些方法也会占用内存。优点，开发方便，java叫做面向对象编程，它里内容都是类，类实例化后就是对象。包装类型本身就是对象，可以和这些对象无缝衔接。但是基本类型就必须转换。开发起来非常方便，直接调用对应方法即可。缺点：占内存。
总结：
1） 面向对象和面向过程：思考方式完全不同，实际开发中两者结合
a) 面向过程，关注点：过程，第一要干什么，第二步要什么。第一步，找个大象，第二步，把冰箱门打开，第三步，把大象放入冰箱（思考过程）
b) 面向对象，关注点：实体（大象（属性：名字、大小、尾巴。。。，行为：方法，跑，跳，嬉戏。。。），冰箱，一般语言描述中的名词）
2） 类和对象
a) 类就是蓝图，图纸，死的，不能直接访问其内部东西 HelloWorld
b) 对象，创建类的实例，活的，就可以访问类中属性和行为 HelloWord hw = new HelloWorld(); ，hw就叫对象，实例
3） 类由三部分内容组成
a) 构造方法，起初始化值作用。private String name;这里没有设置它的值，可以通过构造方法来设置值。
b) 成员变量（属性），传递数据，封装数据。把数据暂时存下来，别处就可以访问
c) 普通方法（行为），加工数据，add(x,y) = x+y。算法。
4） 构造方法
a) 默认构造，创建对象必须有默认构造。如果不写默认构造，又没有其他构造方法，java编译时就会自动添加默认构造。如果有其他构造方法，哪怕带参也不会创建。
b) 有参构造方法，可以多个参数，看业务情况People(String name, Integer age, String address。。。)在设置时，用户就可以通过有参构造方法，传递参数值进来。相当于默认设置。
c) 规定：没有返回值；方法名必须和类名一致。可以有参数，可以没有参数，不能重复。默认构造方法只能有一个。创建类时，只需要一个构造方法就可以创建。不需求调用其它构造方法。
5） 成员变量和局部变量
a) 成员变量是从属类的，这个类中都可以直接使用成员变量
b) 局部变量是从属方法的，局部变量只能在方法内有效，出去就用不了了
这些叫做变量声明周期。成员变量类中长，类的对象实例消亡，才不可用。局部变量方法结束就消亡，短
6） POJO 简单或者纯粹的java对象
a) 规定：只能有2个内容。一堆私有属性，一堆get/set方法
b) toString不是给用户用的，所以它存在与否没关系。它是给开发人员调用的。测试值是否正确。
7） User POJO
Public class User{
private Integer id;
private String name;
private Integer age;
//利用eclipse生成所有get和set方法，右键source菜单，generate生成 get/set方法 //利用elipse生成toString方法
}