类与对象

类和对象

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向过程：1、把冰箱打开  2、把大象放入  3、冰箱关起来 
面向对象：打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。
		冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

创建类

声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型

创建类：
class 类名{        // 类名：首字母大写的驼峰模式XxxYyy
    field;//成员属性
    method;//成员方法
}

创建类的时候要注意：
   如果在定义类的时候, public class 类名{} （class 前面带有 public，这个类就是主类）
   一个 java 文件中只能有一个主类，而且这个文件名字必须要和主类名字一致。   
   其他类（不带有 public）与文件没有关系

类里面的属性：
属性就是这个类公有特征，用变量的定义的方式来表示，可以没有初始值，jvm给属性默认值。

创建对象

创建对象语法：
类名 变量名=new 类名();    //（类名 变量名————>引用）
new 类名().属性=...;      // new 关键字用于创建一个对象的实例
						// 使用 . 来访问对象中的属性和方法

通过对象可以访问属性：引用.属性名字
通过对象可以访问方法：引用.方法名(...)

用同一个类创建多个对象，每一个对象都有自己的属性，每一个对象都是数据隔离的。

1、类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
2、一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
3、类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

构造器：用于创建对象的方法

构造方法是一种特殊方法，使用关键字 new 实例化新对象时，会被自动调用，用于完成初始化操作。

new 执行过程：
1、为对象分配内存空间
2、调用对象的构造方法

权限修饰符 类名(数据类型 参数名,...){
}

1、构造器本身是一个方法，没有返回值，也没有void；
2、构造器的方法名必须和类名一致，在方法中定义可以初始化参数列表；
3、每一个类中至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）。

注意：
1、如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数；
2、一个类存在有参数的构造器，那么默认的构造器就会被覆盖，如果想要使用默认构造器，需要显示的定义（手写出来）；
3、构造方法支持重载，规则和普通方法的重载一致。

构造器之间的调用：
同一个类中构造器可以相互的调用，需要通过 this(…)来调用。

例：this(...)必须放在第一行
class Hero{
   String name;
   int age;
   public Hero(){}    //默认构造器
   public Hero(String name){
      this.name=name;
   }

   public Hero(String name,int age){
      this(name);      //构造器调用构造器
                       //必须放在第一行
                       //在构造器中调用其他构造器，不再创建对象，只初始化
      this.age=age;
   }
}

this 关键字

this 只能存在 对象方法之内使用（对象方法：不带 static 的方法）
this 就是调用 这个方法的那个对象的引用

对于类的对象来说，属性是每个对象都有一份数据隔离的。
但是方法是多个对象共享，不同的对象调用这个方法的时候用this来区分不同对象的数据。
this是可以隐藏的。

对象方法调用对象方法：
本类的对象方法可以直接调用对象方法，隐藏了this。

this 可以区分同名的属性和局部变量的名字：this.name=name;

public void setName(String name){   //给 name 赋值
	this.name=name;
}
public String getName(){    //获取 name
	return name;
}
public void setAge(String age){
	this.age=age;
}
public int getAge(){
	return age;
}

static 关键字

1、修饰属性（加上 static 的属性是类属性，静态属性（和类相关，和具体的实例无关））

1. 同一个类的不同实例共用同一个静态属性.（所有类共享，且不属于对象）
2. 类属性的访问可通过 “类名.类属性”、“对象.类属性”
3. 类属性的当前的class文件加载进入jvm，类属性就会被初始化，jvm执行完 .class文件出来jvm，类属性也就消失了。
4. 类属性可以被这个类每一个对象共享。

class Hero{
   String name;
   static int age;
}
public class TestHero{
   public static void main(String[] args){
      Hero h=new Hero();
      h.age++;

      Hero h1=new Hero();
      h1.age++;
      System.out.println(Hero.age);     //结果  2
   }
}

2、修饰方法（类方法）
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

1. 类方法的访问可通过 “类名.类方法”、“对象.类方法”
2. 类方法的当前的class文件加载进入jvm，类方法就会被初始化，jvm执行完 .class文件出来jvm，类方法也就消失了。
3. 对象方法和类方法都是被对象共享。类方法初始化很早，jvm加载这个类的时候就初始化了。
   对象方法也是早就进入jvm了，但是并不一定被启用了，只有先创建了对象，才有可能使用这个方法。
4. 类方法无法访问对象属性和对象方法（类方法只能访问类属性和类方法）
5. 对象方法内可以访问对象属性，对象方法，类属性，类方法

静态方法和实例无关, 而是和类相关：
静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的). 
this和super两个关键字不能在静态上下文中使用
(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关)

总结：所有被static所修饰的方法或者属性，全部不依赖于对象

3、代码块

语法：
class A{
   //静态代码块
   static{
   }
}
1. 静态代码块主要是用于初始化资源
2. 静态代码块在 main 之前执行
3. 静态代码块可以访问类属性和类方法

class Person{
    private String name;//实例成员变量
    private int age;
    private String sex;
    private static int count = 0;//静态成员变量 由类共享数据 方法区

	// 构造方法
    public Person(){
        System.out.println("I am Person init()!");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    //静态代码块
    static {
        count = 10;//只能访问静态数据成员 
        System.out.println("I am static init()!");
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }

}
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();//静态代码块是否还会被执行？
    }
}

// 运行结果

I am static init()!
I am instance init()!
I am Person init()!
I am instance init()!
I am Person init()!

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的
静态代码块 > 实例代码块 > 构造函数

4、修饰类

小结

class Person {
    public int age;//实例变量 存放在对象内
    public String name;//实例变量
    public String sex;//实例变量
    public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
    public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
    public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改
    
    //实例成员函数
    public void eat() {
        int a = 10;//局部变量 
        System.out.println("eat()!");
    }
    //实例成员函数 
    public void sleep() {
        System.out.println("sleep()!");
    }
    //静态成员函数
    public static void staticTest(){
        //不能访问非静态成员
        //sex = "man"; error 
        System.out.println("StaticTest()");
    }
}

public class Main{
    public static void main(String[] args) {
        //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        System.out.println(person.age);//默认值为0 
        System.out.println(person.name);//默认值为null 
        //System.out.println(person.count);//会有警告! 
        //正确访问方式：
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
        person.eat();
        person.sleep();
    }
}

// 运行结果

0 
null 
0 
99 
StaticTest() 
eat()! 
sleep()!

数据属性的内存布局：