往期：
JAVA 修炼秘籍第一章：《痛苦的折磨》
JAVA 修炼秘籍第二章：《逐渐魔化》
JAVA 修炼秘籍第三章：《绝地反击》
JAVA 修炼秘籍第四章：《闭关修炼》

文章目录

• 一、类和对象
• • 1.类的实例化
  • 2.属性
  • 3.方法
• 二、static关键字
• • 1.修饰属性
  • 2.修饰方法
• 三、封装
• 四、构造方法
• 五、代码块
• • 1.实例代码块
  • 2.静态代码块

一、类和对象

开起重要知识点，JAVA语言是面向对象的，那么什么是面向对象呢？下面图是我脑子里第一个想到的画面请欣赏

哈哈哈哈，是不是很神奇，但是面向对象真的就是这么甜蜜吗，我们来正确理解一下什么是面向对象。

注释部分： 面向对象只是一种思考方式，可以把一个复杂的问题变得简单只要面向一个对象即可，类就是一类的统称，对象就是这一类具体化的实例。

1.类的实例化

通过实例来理解感受，比如有一个很大的花坛，这个花坛可以种很多的花，那么这个花坛就是一个类，由这个花坛（类）可以种（生成）很多的花（对象）。
一个类可以实例化产生很多个对象。
接下来我们看代码中如何生成一个类：

（1）class Person{                                 
（2）    public int age;                           
（3）    public String name;
（4）    public String sex;
（5）    public void study(){
	         System.out.println("学习");
	     }
（6）    public void up(){
 	        System.out.println("向上");
	     }
	 }
 	public class Prog {
	     public static void main(String[] args) {
（7）        Person person=new Person();
（8）        person.study();
（9）        person.up();
（10）        System.out.println(person.age);
（11）        Person person2=new Person();
（12）        Person person3=new Person();
   	 	  }
   	 }

注释部分（按照对应数字，进行注释）；
1：创建类的关键字class后面Person为类名
2：成员属性，实例变量。
3：与2相同
4：与2相同
5：成员方法
6：与5相同
7：创建Person类的对象，类中的非静态属性与方法都可以通过该对象来进行引用或调用。（非静态与静态后面理解）。
8：对象名加.即可访问类中属性与方法。
9：与8相同。
10：与8相同。
11：我们前面说到，一个类可以创建多个对象，创建过Person我们后续还可以创建很多。
12：与11相同。

注意事项：
1：实例化一个成员需要，为对象分配内存。
2：调用合适的构造方法。

2.属性

如果属性未初始化，那么默认值是多少？属性在创建时除非必要，尽量不要赋初始值。

引用类型默认为  null。
简单类型默认为  0。
Boolean默认为  false。
char默认为     '\u0000';

3.方法

方法中还有一种方法称为“构造方法” 在实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于对象的初始化.
虽然我们前面已经能将属性就地初始化, 但是有些时候可能需要进行一些更复杂的初始化逻辑, 那么就可以使用构造方法.
后面我们会详细介绍构造方法的语法.

二、static关键字

static关键字，是可以修饰属性，方法，代码块，类。

1.修饰属性

当你将属性修饰后，这个静态的属性就有类相关，而不是与实例对象相关， 看一段代码，我们通过图片来理解：

class TestDemo{
    public int a;
    public static int count; }
public class Main{
    
 public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo.count);
        System.out.println("============");
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo.count);
   }
}

注释部分：
1：当属性count被static修饰后，所有类都可以共享，并且不属于对象。
2：访问方式也发生改变，被static修饰后访问形式变为：
类名（TestDemo）. 属性（count）

2.修饰方法

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

class TestDemo{
    public int a;
    public static int count;
    public static void change() {
        count = 100;
        //a = 10; 不可以访问非静态数据成员
   }
}
public class Prog{
 public static void main(String[] args) {
        TestDemo.change()；//无需创建实例对象 就可以调用
        System.out.println(TestDemo.count);   
   }
}

注释部分：
1.静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
2.this和super两个关键字不能在静态代码块中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关).

三、封装

在说封装前先理解一下，下面这三位访问修饰限定符是干嘛用的。

public——>公有的。
private——>私有的。
protected——>受保护的。
如果你在创建时什么也不加，默认为——>包访问。

作用：
封装就是用private来修饰属性或方法，修饰后的属性或方法只能在此类中使用。

当修饰过后，安全度大大提高，访问方式方法也不一样了，代码如下：

class Person { 
	private String name;
 	private int age; 
	public void setName(String name){ 
		this.name = name;
	} 
	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(); 
}

注释部分：

1.当修饰过后我们发现，类创建的实例对象，没有办法直接进行访问，而是通过类中的方法进行访问，
2.从中可以看出代码的安全程度，也不会随着类中修改属性成员名导致后续代码大费周章。
3.get是获取，set是修改，Alt+insert (f12),可以快捷创建这两个方法。

四、构造方法

作用：
构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作。
在我们通过new创建了一个实例对象后如果你没有创建构造方法，编译器会为你自动创建一个默认无参构造方法来进行初始化，如果自己创建了，编译器则不会自动再生成。
构造方法支持重载，方法与往期内容中的重载方法相同。
下面看一下代码：

class Person {
    private String name;
    public Person1() {
        this.name = "zhang";
    }
    public Person2(String name) {
        this.name = name;
    }
}
public class Prog{
    public static void main(String[] args) {
        Person person = new Person1();
        Person person2 = new Person("zhang");
    }
}

注释部分：
Person1为编译器默认生成的构造方法，给实例出来了，正常不会显示。
Person2为自己创建的构造方法
注意事项：
构造方法名必须与类名相同。
构造方法没有返回值类型。
每一个类中都会有一个构造类型，你不创建编译器也会给你默认创建。

五、代码块

什么是代码块，不知如何为君表达，还是画一下吧。

每个颜色对应的就是代码块。
代码块分为如下4种：
1：本地代码块——>不常用。
2：实例代码块——>定义在方法的外面，类的里面。
3：静态代码块——>定义在方法的外面，类的里面。
4：同步代码块——>我也不会，嘻嘻。
我们先了解2，3就可以1不常用。

1.实例代码块

构造代码块一般用于初始化实例成员变量，且只能初始化实例成员。
代码如下：

class Person{
    public String name; 

    {
		this.name = "zhang"; 
	}
}
public class Prog {
    public static void main(String[] args) {
    	System.out.println(person.name);
    }
}

2.静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。且只能初始化静态成员。
代码如下：

class Person{
    public static String name; 

    {
		this.name = "zhang"; 
	}
}
public class Prog {
    public static void main(String[] args) {
    	System.out.println(Person.name);
    }
}

注意事项：
1.生成多少个静态代码块，都只会执行一个。
2.静态代码块是程序运行时最先执行的。

运行顺序是：
静态代码块——>实例代码块——>构造函数。

本章结束，感谢观光，下章再见。