简介：从这里开始就要开始学习Java高级部分了。主要学习以下部分：
- 面向对象的
- 继承多态
- 包，抽象类，接口
- 常用的集合框架，泛型，异常
- IO流，多线程，网络编程，反射机制
- Java中的JDBC
1-1 面向对象概述：
面向对象简称oo(Object Oriented) 也称面向思想，是一种面向思想，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做？面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象，分类，继承，聚合，多态，封装，。其三大特征是：封装，继承，多态(抽象)
1-2 建立面向对象的思维：
1.先整体，在局部
2.先抽象，再具体
3.能做什么，再怎么做
通俗的来讲就是
1.现在家庭内部讨论要不要买车
2.买什么价位的车
3.买什么类型的车
4.钱从哪里来
5.签订合同，开始还贷款，怎么还？
6.什么时候提车？谁去开？
7.你高高兴兴的开回家
1-3 类和对象
什么是类？什么是对象？
类：是对相同特征或属性，具有相同行为能力的一列具体事物的描述合作称呼，是概念上的定义
对象：是实际存在的该类事务的每个个体，因而也称为实例(instance)
关系：类是对象的抽象，对象是类的具体
1-3-1 类的定义：
权限修饰符 class 类名{ }
如何使用类？
类的定义是对某一事物的描述是一种抽象，要想使用就必须创建该类的对象。使用new关键字
Car car = new Car();
1-4 属性和局部变量
1.相同点：
1.定义变量的格式：数据类型 变量名 = 变量值;
2.先声明，后使用
3.变量都有其对应的作用域
2.不同点：
1.位置不同：
属性：直接定义在类的{}内
局部变量：声明在方法内，方法形参，代码块内，构造器...
2.局部变量不可以使用修饰符的；
3.属性加载到堆空间中(比如：数组，(非static)对象)
局部变量加载到栈空间中
小示例让你看一波：
public class Person { //属性 String name; int age; boolean isMale; //方法 public void eat() { System.out.println("人可以吃饭"); } public void sleep() { System.out.println("人可以睡觉"); } public void talk(String englishi) { System.out.println("人可以吃饭，使用的语言是：" + englishi); } public static void main(String[] args) { //创建Person对象 Person per = new Person(); //调用属性 per.name = "Tom"; per.age = 18; per.isMale = true; System.out.println(per.name);//Tom //调用方法： per.eat();//人可以吃饭 per.sleep();//人可以睡觉 per.talk("Chinese");//人可以吃饭，使用的语言是：Chinese } }
1-5 封装性
-
封装性的体现：
将类的属性私有化同时提供公共的方法来获取和设置
<!--set()有参无返，get()无参有返-->
-
权限修饰符：
<!--封装性的体现需要权限修饰符来配合-->
从小到大：private ,缺省(default),protected,public
1-6 构造器(构造方法)
1.概述：构造方法是一种特殊的方法，用来创建对象，分为无参构造方法和有参构造方法，如果没有显示的定义类的构造器，系统会自动提供一个空参的构造器 ，当定义了有参构造器之后系统则不会提供。
2.定义构造器
权限修饰符 类名(形参列表){}
3.属性赋值的顺序
① 默认初始化
② 显示初始化
③ 构造器中初始化
④ 通过 ‘对象.方法’ 或 ‘对象.属性’的方式赋值
最终的值从后往前看
1-7 JavaBean
1.概述：
JavaBean是一种java语言写成的重用的组件
符合如下标准的：
类是公共的
有一个无参的公共的构造器
有属性，并且有对应的get,set方法
2-1 this关键字
1.this关键字的使用：
可以用来修饰：属性，方法，构造器
2.this修饰属性和方法；
3.在类的方法中，我们可以使用this.属性 或 this.方法的方式，来调用，如果方法的形参和类的属性同名时，必须使用this.来表示
4.在构造器中调用构造器
1.必须放在调用者的首行位置
2.在类的构造器中，可以显示的使用‘this(形参列表)’的方式来调用指定的类的其他构造器
3.构造器不能调用自己本身的构造器，不能回调，不能同时调用两个
2-2 static关键字
概述：
我们希望无论是否产生了对象(new)或无论产生了多少对象的情况下，某些特定的数据在内存中只有一份，不归对象所有。所以引入了static关键字
使用：
静态的可以用来修饰：属性，方法，代码块，内部类
通过：类.静态变量 方式访问
1.使用static修饰属性：静态变量(类变量)
多个对象共享改静态变量，当某个对象修改静态变量时，其他对象调用则是修改过的，随着类的加载而加载，是早于对象的，只存在一份，存在方法区的静态域中。
类变量 实例变量(非static)
类 yes no
对象 yes yes
随着类的加载而加载的，可以通过 类名.静态方法 调用
静态方法 非静态方法(普通方法)
类 yes no
对象 yes yes
注意事项：静态方法中只能调用静态方法或属性
非静态方法中都能调用
static方法内不能使用this，super关键字
package 第一章; public class Test { public static void main(String[] args) { System.out.println(a); System.out.println(new Test().b); eat(); new Test().ead(); } public static int a = 10; public int b = 20; //方法 public static void eat() { System.out.println("这是静态方法"); } public void ead() { int c = 100; System.out.println("这是成员方法"); } }
2-3 单例设计模式（我没有深入的了解，只是借用下书上的知识）
概述：
所谓单例：就是采取一定的方法保证在整个软件系统中对某个类只能存在一个对象实例。并且提供一个区的其对象实例的方法，如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置成private，这样外部就不能产生了。但是在类的内部还可以产生，因为外边无法得到，所以只能调用该类的静态方法，座椅该类的对象的变量也必须定义成静态的
步骤：
2.内部创建类的对象，也必须是静态的
3.提供公共的静态方法，返回类的对象
饿汉式：
好处：线程安全的
坏处：加载时间过长
public class SingletonTest { public static void main(String[] args) { /*Bank bk = new Bank();*/ Bank bank1 = Bank.getIns();//创建对象 Bank bank2 = Bank.getIns(); System.out.println(bank1.equals(bank2)); } } class Bank{ //1.私有化类的构造器 private Bank() { } //2.内部创建类的对象，也必须是静态的 private static Bank inst = new Bank(); //提供公共的静态的方法，返回类的对象 public static Bank getIns() { return inst; } }
懒汉式
好处：延迟对象的创建
目前写法的坏处：线程不安全的(中间有改成线程安全的操作)
public class SingletonTest2 { public static void main(String[] args) { Order inse1 = Order.getInse(); Order inse = Order.getInse(); System.out.println(inse.equals(inse1));//true } } class Order{ //1.私有化类的构造器 private Order() { } //2.声明当前类对象，没有初始化 private static Order ist = null; //3.声明public，static的返回当前的方法 public static Order getInse() { if(ist == null) {//判断这个对象它是不是等于null //改造成线程安全的 synchronized(Order.class){ ist = new Order(); } } return ist;//不是的话直接返回 }