Java类和对象

1、什么是类和对象

  在了解类和对象之前，我们要知道C语言是一门面向过程的语言，而Java是面向对象的语言。面向过程注重的解决问题的过程，分析出如何解决问题的每一个步骤，然后通过函数将其实现；而面向对象则是注重对象，即在问题中涉及到的各个对象，通过对象之间的交互来实现。举一个简单的例子：“学生们交作业，老师批改作业”，这一事件在面向过程的解法是学生们先上交作业给老师，老师批改每一位学生的作业，学生们查看批改结果；而面向对象的解法则是将“学生”、“老师”和“作业”分为三个不同的对象，通过学生向老师交作业，老师批改作业这样对象之间的交互来完成整个事件。

面向过程：

面向对象：

而所谓的类，其实就是面向对象中的那个“对象”，简单来说就是如上的学生、老师、作业都是我们创造的“类”，通过对这些类的操作来完成我们想要的功能。

2、类和类的实例化

//创造类
class Student{
    //成员属性
    public String name;
    //成员方法
    public void handInHomeWork(){
        System.out.println("学生交作业！");
    }
    public Student(){
        System.out.println("我是学生!");
    }
}

  如上述代码就是我们创造了一个“学生”类，“class”后的"Student"就是类名,类名采用大驼峰命名方式，类中的元素称为成员属性或者成员变量，类中的方法称为成员方法。细心的你可能注意到了，上述代码中的一个成员方法名与我们的类名相同，这就是构造方法。与类名同名的成员方法叫做构造方法，构造方法是在实例化类的时候程序默认会执行的方法，那什么是类的实例化呢？

public class Main{
    public static void main(String[] args){
        Student s1 = new Student();
    }
}

  在上述代码中我们通过Student类创建了一个对象“s1”，这就是类的实例化，而之前我们说过，在实例化类的时候程序会默认执行这个类的构造方法，而在构造方法中会输出“我是学生！”，所以在我们执行这个程序的时候会输出“我是学生！”。执行程序：

  用类来创建对象，就是类的实例化。一个类可以创建或者说实例化出多个不同的对象，实例化出的对象占用实际的物理空间。就好比学生，我们知道学校中有学生，所以教室中要有座位，这就是类；而具体有多少个学生，才会有多少个座位，这就是实例化。没有实例化的类就是虚拟的，我们知道有“学生”的存在，但是没有实例化也就是没有给“学生”安排座位，也就没有占用空间，实例化一个“学生”，就是实实在在有了一个学生，这时才会有一个座位，才会占用空间。

3、类中的属性、方法  

在实例化了一个对象之后，我们可以通过“对象名（如上述s1）. 成员属性或者成员方法”，来访问这个对象中的成员属性或成员方法。

public class Main{
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println(s1.name);
        s1.handInHomeWork();
    }
}

  执行结果：，这里输出null是因为我们没有对s1.name进行初始化，而在这里有一个默认规则，未初始化的数字类型的默认值是0，boolean类型的默认值是false，String及其他引用类型或自定制类型的默认值为null。我们可以通过“对象名.name = 字符串 ”来对成员属性进行赋值，或者使用构造方法：

class Student{
    public String name;
    //不带参数的构造方法
    public Student(){
        System.out.println("我是学生");
    }
    //带参数的构造方法
    public Student(String name){
        this.name = name;
        System.out.println("我是学生"+this.name);
    }
}
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();      //调用不带参数的构造方法
        System.out.println(s1.name);
        s1.name = "张三";                //为s1.name赋值
        System.out.println(s1.name);
        Student s2 = new Student("李四");//调用带参数的构造方法
        System.out.println(s2.name);
    }
}

  执行结果：

  如上述代码Student类中我们创建了两个构造方法，这两个构造方法大体相同，唯一不同的地方是参数。在main函数中，我们创建第一个对象s1时，new Student()的括号中没有任何参数就说明调用不带参数的构造方法，所以我们的s1.name是没有进行初始化的；而创建第二个对象s2时，new Student()的括号中放参数字符串“李四”，这就调用了带参数的构造方法，而在带参数的构造方法中我们对name进行了赋值：“this.name = name”，细心的你可能又注意到了这里的两个name怎么一个有 “ this. ”一个没有，这是因为this表示的是当前对象引用。第一个this.name表示当前对象的成员属性public String name的“name”，而第二个name表示调用构造方法时传进来的字符串参数“name”。这样写既是因为当前对象里调用了类的成员属性，又有利于我们分清成员属性和传进来的参数。若是实在觉得分不清，可以将参数String name改成String studentName或者其他，但是前面的成员属性的“this.”可不能省去，同样的，若是当前对象里，一个成员方法调用了另一个成员方法时，也要加“this.” 。

4、static修饰

  在类中，我们的成员属性和成员方法都可以使用static来修饰，一旦使用了static来修饰，那么这个属性或者方法就叫做静态属性或者静态方法。静态属性和类相关，和具体的对象（实例）无关，可以通过类来直接访问，换句话说，静态属性是可变的，同一个类的不同对象共用同一个静态属性。

public Student {
    public String name;
    public static int count;//默认值是0
    //成员方法
    public static void change(){
        count = 100;  //将count计为100
    }
    //构造方法
    public Student(){
        count++;  //每创建一个新的对象或实例化就加一
        System.out.println("我是学生!");
    }
    public Student(String name){
        count++;
        this.name = name;
        System.out.println("我是学生"+name+"!");
    }
}

  如上述代码，我们定义了一个静态成员属性count，这个属性表示当前我们有多少个学生，在两个构造方法中我们都有“count++”，也就是说每创建一个新的对象，学生的人数就会加一。就会你可能双注意到了，为什么这里的“count++”没有“this.” ？这是因为this是当前对象引用，与对象有关，而count是由static来修饰的，与类相关。

public class Main {
    public static void main(String[] args) {
        System.out.println(Student.count);//没有创建任何对象
        Student s1 = new Student("张三");
        Student s2 = new Student("李四");
        Student s3 = new Student("王五");
        System.out.println(Student.count);//创建了3个对象之后
        s1.count++;
        System.out.println(s2.count);
        Student.change();       //调用静态方法
        System.out.println(Student.count);
    }
}

  执行结果：

  如上述代码，①第一次输出count为0是因为这时的count我们既没有初始化也没有赋值，所以是默认值0；②当我们创建了3个对象之后（调用构造方法时count++，具体见上述构造方法）count输出为3；③然后通过s1来调用count使其加1，再通过s2来将其输出，结果为4，这也说明同一个类的不同对象是共用同一个静态属性的。④调用了静态方法，将count计为了100。注：静态方法只能调用静态属性。

5、封装

  软件开发的本质就是对程序复杂程度的管理，如果一个软件的代码复杂程度太高，那么对它进行维护的难度就会很高，甚至无继续维护。而封装，就是管理代码复杂程度最基本的方法。在我们写代码时，关于类会有两种角色：“类的实现者”和“类的调用者”。封装的本质就是让类的调用者不必太多的了解类是如何实现的，只知道如何使用类就行了。这样就降低了类的调用者的学习和使用成本，从而降低了复杂程度。

  在学习封装之前我们需要先了解public和private这两个关键字。被public修饰的成员变量或方法可以被类的调用者访问，而被private修饰的成员变量或方法不能被类的调用者访问。由此可见我们可以使用private来对类中的成员变量或方法来进行修饰，而提供必要的public方法供类的调用者使用，这样就可以让调用者不用对类的内部进行深度学习也能使用这个类，降低了调用者的学习成本。下面我们使用private关键字来实现封装。

class Student {
    private String name = "张三"; //private修饰变量不可访问
    private int age = 16;
    public void show(){
        System.out.println("我是学生" + this.name + "，我今年" + this.age + "岁了。");
    }
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        //s1.name = "李四";  //报错，name被private修饰
        s1.show();
    }
}

  执行结果：，若是强行访问被private修饰的变量， 就会报错，这就是封装。

  那么我们要是想要修改被private修饰的变量，就是头铁就要访问该怎么办呢？答案是使用Getter and Setter方法，这个方法就是为封装提供的。在这里有个快捷键，在我们的封装类中按键Alt + Insert (Ins)就会出现这个界面：，选择其中的Getter and Setter会出现，接下来摁住Shift键+方向键中的↓，就可以选中两个被我们用private封装的成员变量了，再按回车键就会自动生成两个变量相应的Getter and Setter方法了。

public class Student {
    private String name = "张三";
    private int age = 16;
    //name属性的Getter and Setter方法
    //getName就是Getter方法，表示获取name变量的值
    //setName就是Setter方法，表示设置name变量的值
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //age属性的Getter and Setter方法
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println("我是学生"+ this.name +"，我今年"+this.age+"岁了。");
    }
}
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.show();
        s1.setName("李四");//调用set方法将“张三”变为“李四”
        System.out.println(s1.getName());
        s1.setAge(22);//调用set方法将16变为22
        System.out.println(s1.getAge());
        s1.show();
    }
}

  执行结果：。

以上就是小弟目前对Java类和对象的理解了，欢迎大家补充~