一、基本数据类型的封装类：
基本数据类型 封装类
Boolean Boolean
byte Byte
char Character
short Short
int Integer
long Long
float Float
double Double
1.每一个封装都有两个构造方法：
public Constr(datatype value);//datatype表示对应的基本数据类型
public Constr(String value);
例如：
int a=12;
Integer inte=new Integer(12);
Integer inte=new Integer("12");
2.每一个封装类都有一个parseXXX()的方法，其中XXX表示对应的基本数据类型，
该方法可以将对应的数字字符串转换为对应的基本数据类型
String num="1234";
int myInt=Integer.parseInt(num);
String dou="123.45";
double myDouble=Double.parseDouble(dou);
3.把数字转换成字符串：
int myInt=1234;
String myString=""+myInt;
练习：定义一个字符串，赋值为"45.65",把它转换为double类型的数据，
再定义一个字符"45",把它转换为Integer封装类类型，并分别输出。
二、面向对象程序设计
1.对象：对现实世界事物的抽象，对象具有属性和行为。
类：对对象的抽象形成类，可以说对象的抽象是类，而类的具体化是对象，即类的实例化是对象
2.类具有属性和方法
3.类图(UML)
4.在java语言里面，我们使用class关键字来定义一个类,类中具有属性，即成员变量，类中还具备方法，
即成员函数
//class用于定义一个类，类名为Student
public class Student{ //类定义的开始
//属性
public String name; //姓名，是一个成员变量
public int age;
public String sex;
//构造方法(构造函数)：函数名与类名相同，并且没有返回值。作用：1.一般用于属性的初始化。2.用于产生对象
public Student(){
name="lili";
age=21;
sex="女";
}
public Student(String mname){
name=mname;
}
//方法
public void eat(){ //成员函数
//吃饭
}
public void sleep(){
//睡觉
}
public void study(){
//学习
}
}//类定义的结束
5.产生对象：对象是对类的一个具体化，即对类的实例化叫做对象
产生对象的语法：
类名 对象名=new 构造函数
例如：产生名叫"张三"的对象：
Student stu=new Student("张三");
Student stu2=new Student("王五");
注意：对象是通过new操作符开辟的新的内存空间，所以同一个类的不同对象各自维护自己的一套属性
和方法，互相不干扰。
6.通过对象访问属性和方法：
语法：
对象名.属性名
对象名.方法名
例如：把"张三"这个同学的年龄改为22
stu.age=22;
调用"王五"同学的学习的方法
stu2.study();
练习：定义一个汽车类，包含品牌，年份，价格，数量等属性，
具备一个可以给每个属性赋值的构造方法，
同时具备加速、刹车等方法，在方法中输出对应信息，
实例化一个汽车类，产生对象，然后用对象给属性赋值，
再调用相应方法。
7.垃圾回收机制
Java虚拟机提供了一个系统级的垃圾回收器县城，它负责自动回收那些无用的对象所
占用的堆内存，这种内存回收机制成为垃圾回收。
8.方法的重载
1)重载的概念：如果两个或两个以上方法，他们的方法名相同，但是参数不一致(参数类型或参数个数不一致)，
则我们称一个方法是另一个方法的重载。
public int add(int a,int b){
}
public double add(double a,double b){
}
2)重载的条件：
方法名相同
方法参数的类型、个数至少有一项不同
方法的返回值类型可以不同
方法的修饰符可以不同
3)构造方法的重载：满足方法重载的条件
class Person{
public String name;
public Person(){
}
public Person(String mname){
name=mname;
}
}
4)this关键字：代表对象本身
例子：
class Person{
public String name;
public Person(String name){
this.name=name;
}
}
Person p = new Person("lili");
//这个时候this就代表p对象
this关键字还可以在同一个类型调用另外一个构造方法：
public class Student {
public String name;
public int age;
//构造方法的重载，参数个数不同的重载
public Student(String name,int age){
this.name=name;
this.age=age;
}
public Student(String name){
//System.out.println("df");
this(name,-1);//调用带两个参数的构造函数
}
public Student(){
//Student("无名氏");
this("无名氏");//调用带一个参数的构造函数
}
public void study(){
//this("kj",20);
}
}
this关键字调用构造函数的规则：
如果要在构造函数中使用this调用另外一个构造函数，那么该this语句必须作为第一条
只能在构造函数中使用this关键字调用其他构造函数，不能在一般的方法中使用this
来调用其他构造函数
只能使用this来调用构造函数，不能直接使用构造函数名来调用
5)static关键字(静态的)：
用static修饰的成员变量表示静态变量，可以直接通过类名来访问
用static修饰的成员方法表示静态方法，可以直接通过类名来调用
用static羞死的程序代码块表示静态代码块，当java加载类的时候就会执行该代码块。
I.static变量：叫做静态变量，在内存中只有一份拷贝，运行时Java虚拟机只为静态变量分配一次内存，
可以通过直接通过类名来访问，也可以通过对象来访问，但所有对象看到的静态成员变量只有一份，被
所有对象共享，类似与C语言的全局变量。
II.静态方法：可以直接通过类名.静态方法名()进行调用。
III.静态代码块：
static{
}
在虚拟机加载类的时候就会去执行静态代码块，加载类是发生在main函数执行之前的。
也就是说对象还没有在main方法中产生，静态代码块就开始执行了，所以静态代码块中
是不能放置实例变量或实例方法的，因为这是实例(对象)还没有产生。
作业：编写一个Person类，包含姓名，性别，年龄，婚姻状况等属性，编写重载构造方法
以实现多种创建对象的方式，注意在构造函数中使用this关键字
三、面向对象程序设计的三大特性：封装、继承、多态
1.封装：封装(Encapsulation)是面向对象方法的重要原则，就是把对象的属性和操作(或服务)结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。封装是把过程和数据包围起来，
对数据的访问只能通过已定义的接口。
2.继承：子类自动共享父类的属性和方法的机制，一个旧类派生一个新类的机制称为继承，
通过继承派生出来的类我们称为派生类或者子类，而派生出新类的那个类我们称为基类或者父类。
子类除了可以继承父类的属性和方法，还可以扩展自己的属性和方法。
在java中，我们使用extends关键字来表示继承。
class Base{
}
//Sub类继承于Base类，Sub为子类，Base为父类
class Sub extends Base{
}
默认构造函数：当一个类中没有声明任何构造函数时，系统将给该类添加一个默认构造函数，该函数
是一个无参的构造函数，形式如：public Base(){},但是，如果一个类已经有了带参数的构造函数，
那么该类将会失去默认构造函数。
3.访问控制：
public:声明的成员成为共有成员，在类的内部和外部均可访问
protected:在同一个包类的其他类可以访问，包外的类不能直接访问。但是protected有一个特权，
就是无论是在同一个包还是不同的包，子类都可以访问父类的protected成员。
默认：在定义成员的时候，不加任何访问控制的关键字。这种访问控制表示包级作用域，在同一个包
类的其他类可以访问，包外的类不能直接访问。
private:只能在类的内部访问
4. 继承中的构造方法
1)子类在调用自己的构造方法之前将会调用父类的构造方法，调用分两种：
I.显示调用：
super(); //调用父类无参的构造函数
super(实参);//调用父类带参的构造函数
II.隐式调用：如果子类的构造方法中没有使用super关键字显式调用父类构造方法，那么在产生对象时，
子类将自动调用父类的默认构造方法，相当于显式调用super();
2)注意事项：
I.派生类构造方法的调用顺序为：先调用父类的构造方法，再调用派生类的构造方法
II.当父类中有默认构造方式时，子类的构造方法中可以省略对父类默认构造方法的调用(隐式调用)
III.当父类构造方法中没有默认构造方法时，子类必须显示调用父类带参构造方法
3)Object类：所有的Java类都直接或者间接的继承了Object,Object类是所有类的祖先。
如果某个类没有用extends继承于任何类，那么它直接继承于Object
5.多态
1.概念：简单的说是一个对象多种表现形态或者相同的消息(调用同名方法)，被不同的对象接收(与不同的对象绑定)会有不同的执行结果。
2.多态是建立在继承与方法覆盖的基础之上的
3.方法覆盖：如果子类中第一的一个方法，它的名称，参数以及返回类型都与父类的一个方法相同，那么可以说，子类
的该方法覆盖了父类的方法。
4.动态绑定
1）向上转型：安全，可以直接转换,例如:Animal a=new Dog();
2）向下转型：不安全，需要使用强制类型转换，例如不正确的转换：Animal a=new Cat();Dog dog=(Dog)a;X
3）动态多态：当父类的引用指向子类对象时，对方法的调用时动态解析的，也就是说，调用方法时时根据实际对象的类型
来动态选择方法来执行的，这就是动态多态，也称为多态。
5.final关键字(类似于C语言的const)：
1)final所修饰的类不能够被继承
final class Base{
}
public class Sub extends Base{ //final所修饰的类不能被继承
}
2)final所修饰的方法不能被覆盖
3)final所修饰的成员变量为常量，不能被改变
四、抽象类和接口
1.抽象类
从继承层次图中看，会发现类逐渐变得更通用，更抽象，基于此，最上面的这个父类由于非常通用，我们可把它看成其他
类的基础，而不是一个需要使用的可以实例化的类，那么我们将该类成为抽象类
2.语法：抽象类使用abstract关键字来声明：
abstract class Animal{
}
注意：抽象类不能实例化
3.抽象方法：表示该方法必须在该抽象类的子类中提供实现
语法：使用abstract关键字进行声明，并且抽象方法没有实现部分
abstract class Animal{
public abstract void eat();//抽象方法没有实现，只有声明，子类需要去实现它
}
4.抽象类与抽象方法关系：
1)抽象类可以有实例方法。
2)如果一个类包含了一个抽象方法的话，那么该类必须是抽象类
5.接口：对抽象类进行进一步抽象，形成接口，接口只有抽象方法，没有实例方法，而且接口没有构造函数，
不能实例化。
1)语法：声明接口使用interface
注意：接口中可以声明成员变量，但是接口中的成员变量默认是public static final类型
接口中的方法默认是public abstract类型
public interface A{
int CONST=1;//合法，CONST默认为public static final类型
void method1();//合法，接口中的方法默认是public abstract类型
public abstract void method2(); //合法，显式声明为public abstract类型
}
2）实现接口使用关键字implements，类似于类之间的继承，同样可以使用多态
public class B implements A{
//类B需要实现接口A中的所有抽象方法
}
//接口多态的实现
A a=new B();
a.method1();
3)java中的继承只能是单继承
class A extends B,C,D{ //错误的写法
}
java中的类是可以实现多个接口的
class A implements B,C,D{ //正确的
}
4)越抽象的东西越稳定，同学设计程序是尽量多使用抽象思维把要设计的事物抽象成接口，再利用多态来提高程序的
可维护性和可扩展性
家庭作业：
1.给学校安装4个打印机，使用接口和多态的形式来完成
2.查询Java API帮助文档，找到java.io包下的所有类，查看类的说明以及方法的说明，使用IO流完成在C盘根目录
创建一个txt文件，里面输入一些中文字符，再将该文件拷贝到D盘根目录的txt文件中。
类的继承层次图
引用变量内存布局
