不理解Java中类与对象(封装+构造法方法+代码块)等的意义？看完这篇秒懂

一.类与对象的认识

什么是类？什么是对象？
在现实世界中，真实存在的东西，比如吉普车，卡丁车，货车。我们在认识它的时候就会在脑海中将它抽象为一种类别叫做车。 好了，那再计算机世界中，它同样的也会这样做 。

举个例子：八月十五吃月饼，生产月饼会用模具，通过模具生产出各种甜月饼、咸月饼。那么在计算机世界中，模具就称为类，甜月饼、咸月饼就是通过类这个模具实例化出来的来两个对象

也就是说，一个类，可以产生无数的对象，这就像是盖房子之前我们通过图纸可以盖出多坐房子。

二.类的成员

• 声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。类的成员可以包含以下：字段、方法、代码块、内部类和接口等。这里我们先看字段和方法。

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();
}
}

1. 成员属性
   在类中的元素叫做字段/成员方法/成员属性，它的访问修饰限定符可以游四种，public公有的，private私有的，protected受保护的，不写就是默认的default包访问权限。
   
   对于类成员属性可以我们可以直接赋值初始化，但是这样违背我们使用类的初衷，因为我们不希望一开始它的值就被初始化，导致后面实例化对象的成员属性值是一样的。所有成员属性可以不初始化，默认值为下表
   

2. 成员方法
   Person类中提供了的方法，它描述了Person这个类的一种行为，对于static修饰对的静态方法，在访问的时候，直接同类名.方法名访问，例如Person.staticTest就可以访问到。而不加static修饰的实例方法，我们需要通过对象来访问，Person person1 = new Person( )，person1.sleep，对象的引用.方法名。需要注意的是在成员方法中的局部变量是存放在栈上的。

3. static 关键字
   修饰属性 Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性。静态属性的存在方法区上，且只有一份。
   修饰方法此方法称为静态方法,特点是不依赖于对象,静态方法属于类，而不属于对象。可以通过类名直接调用静态方法，而无需创建类的实例。静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
   静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的)
   this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关).

4. 实例化一个对象
   Person person = new Person( ) 这句代码就完成了一个对象的实例化，可以将这一情形想像成用遥控器(引用)来操纵电视机(对象)。只要握住这个遥控器，就能保持与电视机的连接。当有人想改变频道或者减小音量时，实际操控的是遥控器(引用)，再由遥控器来调控电视机(对象)。如果想在房间里四处走走，同时仍能调控电视机，那么只需携带遥控器(引用)而不是电视机(对象).

成员属性内存中存放的位置

三.封装

• 我们使用private/ public 这两个关键字表示 “访问权限控制” ，被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用；被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用。
• 若想修改被 private 修饰的成员属性, 就需要使用 getter / setter 方法，getName 即为 getter 方法, 表示获取这个成员的值.
  setName 即为 setter 方法, 表示设置这个成员的值.
  当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前对象的引用

class Person {
private String name;//实例成员变量
private int age;
public void setName(String name){
//name = name;//不能这样写
this.name = name;//this引用，表示调用该方法的对象
//当set方法的形参名字和类中的成员属性的名字一样的时候，
//如果不使用this, 相当于自赋值. this 表示当前实例
的引用.
}
public String getName(){
return name;
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public static void main(String[] args) {
Person person = new Person();
person.setName("caocao");
String name = person.getName();
System.out.println(name);
person.show();
}

封装的优点：

• 此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节，给类的调用者提供了共有的方法，只调用就好了，降低了代码的管理复杂度
• 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段)，也就相当于类的实现者把零散的东西装进了一个盒子，调用者每次找这个已经包装好的盒子就好了，不必关注盒子内部的具体实现情况；同时因为每次使用的是盒子，当类的实现者修改了盒子内部的细节时候，调用者也无需修改自己的代码。

四.构造方法

• 它的方法名是和类名相同
• 无返回值
• 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
this.name = "caocao";
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: 男

• 那么new一下的时候究竟是如何产生一个对象的？首先要为对象分配内存 ，最后调用合适的构造方法。（构造方法不止一个)

注意

1. 当没有提供构造方法的时，编译器会自动提供一个不带参数的构造方法
2. 若类中定义了构造方法，则默认的无参构造将不再生成
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 = "baozi";
this.age = 1;
this.sex = "boy";
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();//静态代码块是否还会被执行？
}
}

1. 构造代码块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量
2. 静态代码块：使用static定义的代码块，一般用于初始化静态成员属性

注意

• 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
• 静态代码块执行完毕后, 实例代码块（构造块）执行
• 再然后是构造函数执行。
• 而静态成员变量与静态代码块的执行顺序是，按照代码的书写顺序
• 静态的代码块中不能访问非静态的成员

六.匿名对象

• 匿名只是表示没有名字的对象，没有引用的对象称为匿名对象。
• 匿名对象只能在创建对象时使用.如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.

class Person {
private String name;
private int age;
public Person(String name,int age) {
this.age = age;
this.name = name;
}
public void show() {
System.out.println("name:"+name+" " + "age:"+age);
}
}
public class Main {
public static void main(String[] args) {
new Person("baozi",1).show();//通过匿名对象调用方法
}
}
// 执行结果
name：baozi age：1

相信大家看到这里，对于Java中类与对象，成员变量、成员属性、封装、构造方法、代码块、匿名对象等都有了一个新的理解了。