3、类和对象、static关键字和5种对象的创建方式

3.1面向对象思想、类和构造器

面向对象程序设计(OOP)Object Oritend Programing是当今主流的程序设计规范，它已经基本取代了结构化、过程化的程序设计。封装、继承之后，面向对象的第三大特性。

Java就是面向对象的，使用java开发程序，不管做什么样的操作，我们第一步都是从创建对象、获取对象开始，有了对象我们就可以完成一切我们所需要的程序了。
Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下。
使用Java语言去设计、开发计算机程序。软件是模拟现实世界的，面向对象设计思想就是通过代码去高度模拟现实世界事物的。
面向对象是非常接近现实世界的思想，面向对象是几乎所有高级语言都支持的设计，是现今最先进的软件设计思想。面向对象的语言是高级语言。 这里的对象泛指现实中一切具体存在的事物，每种事物都具备自己的，属性和行为，例如我们每个人就是一个对象。
面向对象思想是一种更符合我们对现实世界事物思考习惯的思想，它可以将复杂的事情简单化。
面向对象的语言中，最重要的两个概念是：类和对象。
类是一类具体事务的统称，是一个抽象的概念，对象是类具体存在的实例。
类：是相同事物共同特征（行为，属性）的描述。类是用来描述一类事物的：比如人类，老师类，学生类，动物类等都是类。
属性：就是该事物的特征的信息。例如：人类都有年龄，名字，性别等特征。
行为：就是该事物能够做什么。例如：人类唱歌，跳舞，计算机可以上网，学生学习等都是行为。

类的详细格式如下：
// 类是相同事物共同特征的描述。
// 研究类的格式：
修饰符 class 类名{
// 类中的五大成分。
// 1.成员变量（属性） Field
// 2.成员方法 (行为) Method
// 3.构造器 （初始化类的对象数据的） Constructor
// 4.内部类
// 5.代码块
}

java中一个类的五大成分 ：
1.成员变量（属性） Field
2.成员方法 (行为) Method
3.构造器 Constructor
4.内部类
5.代码块

Java中定义类的注意事项
1.修饰符: public | 缺省,protect 、private，static,final;。暂时无需理解，暂时都用public , 记住即可。
2.类名：首字母应该大写，满足”驼峰模式“，一般是名词。
3.一个Java文件中可以写多个类，但是只能有一个类是用public修饰的
4.public修饰的类名必须成为Java代码的文件名。
5.开发的时候尽量不要在一个Java代码中定义多个类（不规范）。
6.类中有且仅能定义5种成分，我们后面将依次学习完成这5中成分。

成员变量（Field）：成员变量是用来描述类的属性的。
例如：学生类，Java是使用成员变量来描述的。
每个学生类都有，性别，年龄，姓名，学校，班级，地址，电话，…等信息。这些是学生类的属性信息，
以下为成员变量的格式：
修饰符 数据类型 变量名称 =初始值;

成员变量的格式注意事项
1.修饰符：public|private|protected|缺省，static,final,transient;暂时用public
2.数据类型：基本数据类型，引用数据类型。
3.变量名称：必须是合法的标识符，首字母应该小写，满足"驼峰模式"，一般是名词（属性名称）。
4.初始值：可有可无，成员变量的初始值在定义的时候可以不给初始值。
构造器的作用：得到一个对象，并且进行初始化。构造器的方法名一定要与类名一致。构造器是没有返回值类型的。
构造器获取对象的格式 ：类名 变量名 = new 类名()

//构造器的格式：
修饰符 类名(形参列表){
// 构造体代码，执行代码
}

3.2 static关键字的用法
Java中成员（变量和方法）等是存在所属性的，Java是通过static关键字来区分的。static关键字在Java开发非常的重要，对于理解面向对象非常关键。

static 关键字的使用，它可以用来修饰的成员变量和成员方法，被static修饰的成员是属于类的是放在静态区中，没有static修饰的成员变量和方法则是属于对象的。
static 是 静态的意思。 static可以修饰成员变量或者修饰方法。有static修饰成员变量，说明这个成员变量是属于类的，这个成员变量称为类变量或者静态成员变量。 直接用类名，访问即可，因为类只有一个，所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。

静态成员变量定义格式 ：
修饰符 static 数据类型 变量名 = 初始值；

static修饰的静态成员变量例子：

静态成员变量的访问:
类名.静态变量
类名.方法名称

实例变量及其访问 ：无static修饰的成员变量属于每个对象的， 这个成员变量叫实例变量，之前我们写成员变量就是实例成员变量。
需要注意的是： 实例成员变量属于每个对象，必须创建类的对象才可以访问。

实例变量的格式 ：
格式：对象.实例成员变量

静态方法及其访问 ：有static修饰成员方法，说明这个成员方法是属于类的，这个成员方法称为类方法或者静态成员方法。 直接用类名访问即可。因为类只有一个，所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。与静态成员变量一样，静态方法也是直接通过类名.方法名称即可访问。

静态方法的格式：
类名.方法名

静态成员变量的访问:
格式：类名.静态方法

实例方法及其访问 ：无static修饰的成员方法属于每个对象的， 这个成员方法叫实例方法，创建对象就是实例化。
需要注意的是：实例方法是属于每个对象，必须创建类的对象才可以访问。
实例化方法的格式如下：
格式：对象.实例方法

Static知识总结 ：
1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。
2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。
3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。
4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。

不建议用对象去访问静态变量或者静态方法，因为静态变量和静态方法可以直接同类名访问，完全没有必要用对象访问

成员变量和局部变量区别 ：
在类中的位置不同 重点 ：
成员变量：类中，方法外 局部变量：方法中或者方法声明上(形式参数)
作用范围不一样重点：
成员变量：类中 局部变量：方法中
初始化值的不同重点：
成员变量：有默认值 局部变量：没有默认值。必须先定义，赋值，最后使用
在内存中的位置不同了解：
成员变量：堆内存 局部变量：栈内存
生命周期不同了解：
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

1.实例方法中是否可以直接访问实例成员（实例方法，实例变量）？可以
从所属性上来看，实例成员都是属于某个对象的，实例方法也是属于对象的，所以实例方法中是可以直接访问实例成员。他们都在对象中。
2.实例方法中是否可以直接访问静态成员（静态方法，静态变量）？可以
静态成员是在静态区中，只有一份，所属性上属于类，可以直接用类名来访问，而所有对象都可以共享静态成员，实例方法属于对象，所以实例方法实际上也是可以直接访问静态成员的。
3.静态方法中是否可以直接访问静态成员（静态方法，静态变量）？可以
静态方法和静态成员都在静态区中，互相可以直接访问。
4.静态方法中是否可以直接访实例成员（静态方法，静态变量）？不可以
实例成员属于对象，必须先创建对象才可以访问。
3.3 Java中有5种创建对象的方式
创建对象的过程也就是实例化的过程。初始化就是往对象里面设置参数
1.使用new关键字 } → 调用了构造函数
2．使用Class类的newInstance方法 } → 调用了构造函数
（运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。）
3.使用Constructor类的newInstance方法 } → 调用了构造函数
4.调用对象的clone( )方法 } → 没有调用构造函数
5.使用反序列化 } → 没有调用构造函数
(运用反序列化，调用java.io.ObjectInputStream对象的 readObject()方法)

1.new调用构造器得到对象格式如下：
类名 对象名称 = new 类名();
// 其中“类名()”是无参数构造器
// 通过new去调用类的构造器，就会得到一个类的对象，构造器会帮助初始化这个对象的数据。

多态： 是指同一行为，具有多个不同表现形式。多态是出现在继承或者实现关系中的，多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

多态创建对象的格式(new关键字)：
父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();
例如：Animal a = new Cat();
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。如果子类没有重写该方法，就会调用父类的该方法。

通过反射机制创建对象 什么是反射机制?
反射机制是java的一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部的成员进行操作。反射机制提供的功能主要有：得到一个对象所属的类；获取一个类的所有成员变量和方法；在运行时创建对象；在运行时调用对象的方法。例如以下例子：
class Base{
public void f(){
System.out.println(“Base”);
}
}
class Sub extends Base{
//重写父类的成员方法
public void f(){
System.out.println(“Sub”);
}
}
public class CreateInstanceTest {
public static void main(String[] args){
try{
//参数必须为类的全路径
Class c=Class.forName(“com.java.test.Sub”);
//创建对象
Base b=(Base)c.newInstance();
b.f();
}catch(Exception e){
e.printStackTrace();
}
}
}
通过反射机制创建对象时，首先通过反射机制加载类获得Class类，获得Class类的方法主要有以下三种：
Class.forName(“类的全路径”);
类名.Class;
实例.getClass();
其次使用newInstance()方法创建该类的对象。

通过反序列化创建一个对象
什么是反序列化？
序列化是一种将对象以一连串的字节描述的过程，可以将对象写在流里进行网络传输，或者保存到文件、数据库等系统里。与序列化相反的是反序列化，它将流转换为对象。
序列化 ：在一台计算机中当一个对象传到，另一台计算机的时候就需要，传输的这台计算的需要把对象变成字符输出流，接收的这台就需要反序列化，接受到对象。

//Serializable–>标志性接口，表示该类的数据成员可以被序列化
public class People implements Serializable{
public String name;
public int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public People(){
this.name=“Lili”;
this.age=18;
}
public static void main(String[] args){
People p=new People();
ObjectOutputStream oos=null;
ObjectInputStream ois=null;
try{
FileOutputStream fos=new FileOutputStream(“people.txt”);
oos=new ObjectOutputStream(fos);
oos.writeObject§;
oos.close();
}catch(Exception e){
e.printStackTrace();
}
//反序列化
try{
FileInputStream fis=new FileInputStream(“people.txt”);
ois=new ObjectInputStream(fis);
People p1=(People) ois.readObject();
System.out.println(“p1和p是同一个对象吗？”+(p1==p));
}catch(Exception e){
e.printStackTrace();
}
}
}