Java中类与对象以及构造方法

一. 类与对象

Java是一种面向对象的的编程语言，其编程核心围绕的就是类与对象。在进入正题之前，我们要先区分一下类和对象两种概念的不同：

类：是具有相同特征的物体的抽象描述，是抽象的、概念上的定义。
对象：是实际存在的某个类的个体，是具体的，也叫做实例

总结一下，也就是说，类是描述对象的一个统称，而对象是类的具体一个实例。

1. 类的创建

类的成员包括两个部分：属性和行为。
类的属性是指该类事物的状态信息，即成员变量。
类的行为是指该类事物能够做哪些事情，能够进行那些操作，即成员方法。
所以，类的定义语法如下：

class 类名称{
	成员变量;

	成员方法;
}

再具体一下，例如我们想要创建一个Person类，类里包含它的名字，年龄，以及他的一些行为（如吃饭、睡觉等），代码如下：

class Person{
	public String name;   //成员变量
	public int age;
	
	public void eat(){    //成员方法
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("睡觉");
	}
}

2. 类的实例化——对象的创建

上文我们提到，对象是类的一个具体个体，所以对象是根据类来创建的，具体方法如下：

> 创建：使用new关键字  类名 对象名 = new 类名（参数）
> 使用：对象名.属性   对象名.方法

我们还是以上文创建的Person类为例子：

//在main方法里创建对象
Person p1 = new Person();   //对象的创建

p1.name = "小猪佩奇";   //对象属性的赋值
p1.age = 6;

String n = p1.name;   //对象属性的调用
int a = p1.age;

p1.eat();    //对象方法的调用
p1.sleep();

3. 类的封装

Java编程语言具有三大特征：封装、继承、多态（也是所有oop语言都具有的特征）
在实际开发过程中，我们难免在通过一些外部程序对类中一些变量赋值的时候出现错误，所以为了避免这些错误，我们就要进行封装，把成员个体隐藏在类的内部，不允许外部程序直接访问，这样有利于保护我们的数据，增强了代码的可维护性。

3.1 权限修饰符

在写代码的过程中，我们一般用访问权限修饰符来对变量进行封装，Java中总共含有4中访问权限修饰符：

public：公共的，在本类、同包、子类等当前程序（项目）中都是可见并且可用的
protected：收保护的，在本类、同包、子类中可以使用
缺省：即前面没写权限修饰符，只能在本类和同包中使用
private：隐私的，只能在本类中使用，外面不能直接访问
（以上权限修饰符范围从上到下依次减小）

仍以Person类为例

class Person{
	private String name;   //封装变量
	int age;
	
	protected void eat(){     //封装方法
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("睡觉");
	}

一般而言，我们通常会对类中的方法用private进行修饰，这样更有利于我们维护代码和数据。但是由于private将变量的访问权限限制在了本类里，所以从外部在想要获取类中的private信息，我们就需要用到setter和getter方法

3.2 setter和getter方法

以Person类为例，我们首先对其内部成员变量进行private封装

class Person{
	private String name;   //成员变量
	private int age;
	``````
	}

我们通常利用setter方法来对对象中的隐私变量进行赋值，用getter方法来获取其具体数据
sette方法的书写

//写到Peoson类里
public void setName(String n){
	name = n;
}
public void setAge(int age){
	this.age = age;
}
//对于age的setter方法，由于其形参与成员变量相同，所以在此方法里，
//形参会把成员变量覆盖掉，但是因为我们要用到成员变量age，所以这里使用了this关键字
//this关键字代表本类的...

setter方法的调用

//实例化对象之后
p1.setName("小马宝莉");
p1.setAge(3)；

getter方法的书写

//写到Peoson类里
public String getName(){
	return name;
}
public int getAge(){
	return age;
}

getter方法的调用

//创建完对象设置完属性后
String name = p1.getName();
int age = p1.getAge();

4. static关键字

static即静态的，当类的成员被static修饰之后，就变成了类的属性，即直接通过类名就可以调用，不需要再实例化对象。

4.1 static修饰成员变量

被static修饰过的成员变量叫做静态变量 通过类名调用
没有被static修饰过的成员变量叫做实例变量，要通过对象来调用

class Person{
	String name;
	static String sex;
	
	public void speak(){
		System.out.println("大家好，我叫" + name + "，性别：" + sex);
	}
}

public class Test{
	public static void main(String[] args){
		Person p1 = new Person();
		Person.sex = "女";  //静态变量直接通过类名调用
		p1.name = "小猪佩奇";  //实例变量通过对象来调用
		p1.speak();
	}
}

运行结果：

注：如果想要定义一个常量，一般用 static 和 final 共同修饰，称之为类的常量，无法能对其再进行修改

4.2 static修饰方法

static修饰的方法称之为静态方法，也是可以通过类名直接访问的

class Person{
	String name;
	static String sex;
	
	public void speak(){
		System.out.println("大家好，我叫" + name + "，性别：" + sex);
	}
	public static void eat(){
		System.out.println("正在吃饭！");
	}
}

public class Test{
	public static void main(String[] args){
		Person.eat();  //直接通过类名调用
	}
}

运行结果：

有关静态方法，我们一般有以下几个注意点：

1. 静态方法属于类，而不属于类的对象，所以静态方法中不支持 this 和 super 的使用
2. 静态方法只能访问静态成员，不能直接访问非静态成员（需要实例化后才可访问）
3. 非静态方法内即可直接访问静态成员，也可以访问非静态成员

二. 构造方法

构造方法属于类中比较特殊的一种方法，在实例化的过程中，其实调用的就是构造方法。
一般而言，构造方法有下面两个用处：

1. 完成对象的实例化
2. 对成员变量进行赋值

1. 语法

权限修饰符 类名（形参列表）{
	构造方法体;  //一般为给类中的成员变量进行赋值
}

需要注意的是：

1. 构造方法的方法名必须与类名一致
2. 构造方法没有返回值
3. 构造方法支持方法重载，一个类中构造方法可以有多个，且一般不省略无参的构造方法

2. 具体例子

class Person {
    String name;
    int age;
    public Person(){   //无参构造方法
        
    }
    public Person(String name, int age){  //含参构造方法
        this.name = name;
        this.age = age;
    }
    public Person(int age){  //只含部分成员变量的构造方法
        this.age = age;
    }

	public void speak(){
        System.out.println("大家好，我叫" + name + "，今年" + 		age + "岁");
    }
}

public class Test{
	public static void main(String[] args) {
        Person p1 = new Person("天线宝宝", 5);
        p1.speak();
}

运行结果：

3. 构造方法的互相调用

在一个构造方法中，我们可以利用 this 关键字来进行对本类中另一个构造方法进行调用
此操作即可理解为给类中的成员变量进行初始化一个默认值

class Person {
    String name;
    int age;
    public Person(){   
        this("猪猪侠", 6);  //无参构造方法中调用含参构造方法
    }
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public Person(int age){ 
        this.age = age;
    }

	public void speak(){
        System.out.println("大家好，我叫" + name + "，今年" + age + "岁");
    }
public class Test{
	public static void main(String[] args) {
        Person p1 = new Person();  //调用无参构造方法
        p1.speak();
}

运行结果：