类和对象总结

面向对象是Java的特性，其中最基础的部分就是类和对象。

1、类的基本概念
本质上是一个高配的结构体，是对一类对象的统称。既包括了数据，也包括了动作（方法）。类存在的意义也是对客观事物进行一个抽象表示。

2、类和类的实例化
类只是一个抽象的，像模型一样的东西，定义出一个类并没有分配实际的内存空间来存储它。如果想要使用这个类，还需要把这个类的变量给创建出来，这个变量就称为“对象（object）/实例（instance）”。一个类可以实例化出多个对象。
创建出对象之后，就可以给这个对象的属性设定一定的值，同时也可以去调用类的方法（.），并且方法内部是可以访问和使用到对象的属性的。
例如
public class Person{ //一个叫Person的类
public String name; //类的属性
public int age;
public void eat() {; //类的方法
System.out.println(“chifan”);
}
}

public class Test{
public static void main(String[] args){
Person person1 = new Person(); //创建Person类的一个对象，通过new实例化对象
Person person2 = new Person(); //另一个对象
person.eat(); //成员方法调用需要通过对象的引用调用
}
}

3、类的成员
类的成员可以包含以下：字段，方法，代码块，内部类和接口等。
其中字段也叫属性，如果类的属性没有初始化，也会有一个默认值。如果是引用类型，初始值为null，如果是内置类型，初始默认值都是0（boolean为false）。
方法中有一种特殊的方法称为构造方法。
(1)构造方法的名字与类名相同；
(2)构造方法没有返回值；
(3)构造方法new对象的同时被自动调用到，用于完成初始化操作。（如果没有明确定义，系统会自动生成一个）。
(4)构造方法支持重载，规则和普通方法的重载一样。
例如：
class Person {
private String name; //实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
this.name = “zhangsan”;
this.age = 10;
this.sex = “男”;
}
//带有3个参数的构造函数
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
p1.show();
Person p2 = new Person(“zhangfei”,80,“男”);//调用带有3个参数的构造函数
p2.show();
}
}
//执行结果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex: 男

4.this关键字
this表示当前对象的引用，我们可以借助this来访问对象的字段和方法。构造实例如下：
//默认构造函数 构造对象
public Person() {
//this调用构造函数
this(“bit”, 12, “man”);//必须放在第一行进行显示
}
//这两个构造函数之间的关系为重载。
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}

5、封装
封装的本质是让调用者不必太多了解类的实现者是如何实现类的，只要知道如何使用类就够了。这样降低了类的使用者的学习和使用成本，降低了复杂程度。
private/public这两个关键字表示“访问权限控制”。被public修饰的成员变量或成员方法，可以直接被类的调用者使用。被private修饰的成员变量和成员方法，不能被类的调用者使用。简言之就是类外不能用。
如果需要获取或修饰private属性，就要使用getter/setter方法（Alt + Insert）。例如：
class Person {
private String name; //实例成员变量
private int age;
public void setName(String name){ //设置成员的值
//name = name; //不能这样写
this.name = name;//this引用，表示调用该方法的对象
}
public String getName(){ //获取成员的值
return name;
}

6、static关键字
修饰属性；修饰方法；代码块；修饰类。
Java静态属性和类相关，和具体的实例无关（与对象无关）。
方法前应用static关键字，称为静态方法。静态方法属于类，不属于类的对象；可以直接调用静态方法，无需创建类的实例；静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
静态方法不能直接使用非静态数据成员或调用非静态方法（者两类都是与成员和方法都是和实例相关）。

7、代码块
代码块有普通代码块；构造快；静态块；同步代码块。
普通代码块是定义在方法中的代码块。例如
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}

构造代码块也叫实例代码块，定义在类中的代码块。例如
class Person{
private String name;//实例成员变量
private int age;
private String sex;
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定义的代码块。例如：
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()!”);
}

8、小结
一个类可以产生无数的对象，类就是模板，对象就是具体的实例。静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
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()!”);
}
}
各个实例变量的存放位置如下图：