Java类与对象

类与对象概念

百度百科：类和对象是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。它们的关系是，对象是类的实例，类是对象的模板。

通俗理解，类可以想象成为一个月饼模子，而对象是由模板制作出来的月饼，显然，对象是可以有多个的。

类的成员

1. 成员变量 / 字段 / 属性

• 普通成员变量
  如果在定义时没有显示设置成员变量的初始值，那么会设置其数据类型的默认值；
  其中：

1. 数字类型 的 默认值 是 0
2. boolean类型 的 默认值 是 false
3. 引用类型 的 默认值 是 null

class Person{
	public String name;
	public int age;
	public String sex;
}

public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);   //null
}

• 静态成员变量

1. 访问方式：类名.成员变量名
2. 为所有类共享，且不属于对象

class Person{
	public String name;
	public int age;
	public String sex;
	public static int count = 0; 
}

public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();

        person1.age++;
        System.out.println(person1.age);  //1
        person2.age++;
        System.out.println(person2.age);  //1

        Person1.count++;
        System.out.println(Person.count);  //1
        Person.count++;
        System.out.println(Person.count);  //2
    }

2. 方法

方法分为：普通方法、静态方法、构造方法；

• 普通方法
  普通方法可以操作调用它从属的对象的属性和参数列表中的参数；
  调用方式： 对象.方法名
• 静态方法

1. 调用方式：可以直接调用静态方法，而无需创建类的实例
   类名.方法名 // 正规调用方式
   对象.方法名 // 不推荐

 public static void staticFunc(){
        System.out.println("静态方法");
    }

public static void main(String[] args) {
        Person person = new Person();
        //person.staticFunc();
        Person.staticFunc();  //类名.方法名
}  

2. 静态方法可以访问静态成员变量，并可以更改静态成员变量的值；但不可以直接访问非静态成员变量或非静态方法

class Person{
	public void eat(){
        System.out.println(age);
        System.out.println(name);
        System.out.println(count);
        staticFunc();
        System.out.println("eat()!!!");
    }
}

 public static void staticFunc(){
        //System.out.println(age); //error
        //System.out.println(name); //error
        System.out.println(count);
        //eat(); //error
        System.out.println("静态方法");
    }

• 构造方法

1. 语法规则：方法名与类名相同；没有返回值；一个类至少有一个构造方法（系统默认生成无参构造）；构造方法支持重载
2. 构造方法用来实例化一个对象分为两步：为对象分配内存；调用合适的构造方法；

public Person(){
        System.out.println("不带有参数的构造方法!");
}
public Person2(String name){
     this.name = name;
     System.out.println("调用带有一个参数的构造函数Person2(String name)!");
}

 public static void main(String[] args) {
        Person person1 = new Person();  
        Person person2 = new Person("hello");  
        System.out.println(person2);
}

3. 代码块

• 普通代码块：定义在方法中的代码块
• 构造代码块 / 实例代码块：用于初始化实例成员变量

class Person{
private String name;
private int age; 
private String sex;
{ 
 	 this.name = "bit"; 
	 this.age = 12; 
	 this.sex = "man"; 
	 System.out.println("I am instance init()!"); 
	} 
}

• 静态代码块：

1. 用于初始化静态成员变量
2. 静态代码块不管生成多少个对象，其只会执行一次
3. 代码块执行顺序：静态代码块 > 构造代码块 > 构造方法；与代码定义的先后顺序无关

class Person{
private String name;
private int age; 
private String sex;
// 构造代码块
{ 
 	 this.name = "bit"; 
	 this.age = 12; 
	 this.sex = "man"; 
	 System.out.println("I am instance init()!"); 
	} 
// 构造方法
public Person(){
        System.out.println("不带有参数的构造方法!");
    }
// 静态代码块
static { 
 count = 10;
 System.out.println("I am static init()!"); 
	} 
}

public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
    }
/*
I am static init()!
I am instance init()!
不带有参数的构造方法!
I am instance init()!
不带有参数的构造方法!
*/
//只执行一次静态代码块

• 同步代码块

封装

百度百科：封装是将数据和代码捆绑到一起，对象的某些数据和代码可以是私有的，不能被外界访问，以此实现对数据和代码不同级别的访问权限。防止了程序相互依赖性而带来的变动影响，面向对象的封装比传统语言的封装更为清晰、更为有力。

1. 使用private封装属性，并提供 public 方法供类的调用者使用.

class Person { 
 private String name = "张三"; 
 private int age = 18; 
 
 public void show() { 
 System.out.println("我叫" + name + ", 今年" + age + "岁"); 
 } 
} 

class Test { 
 public static void main(String[] args) { 
 Person person = new Person(); 
 person.show(); 
 } 
} 

2. 使用private封装属性，使用getter和setter方法来获取私有成员变量

• 当形参与类中的成员变量的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用
• 在IDEA中可以使用Alt + Insert 快速生成 setter / getter 方法

public void setName(String name){ 
 this.name = name;//this引用，表示调用该方法的对象
 }