Java基础：类，对象和封装

1、类和对象

对于面向对象编程来说，我认为类比对象更加重要和也更难以理解。其实类就可以看成是C语言中的抽象化结构体。结构体是自己定义一堆变量的集合，然后集中使用，而类的概念几乎就是这样一个数据和算法的集合。比如当我们要使用一个student的结构体，我们在java中就可以创立一个叫Student的类（类的首字母要大写）

然后就是设置设置类的属性了，这就好比是结构体中的的一个个自定义数据了。但是这还不算结束，当我们要想真正地使用这个类的时候，我们就要创立一个具体的对象，这的对象就好比是一个指向这个类的一个指针，能得到内存分布的只有类中设置的成员变量，而对象只是一个数据输入的窗口，一个名副其实的指针，指向类所对应的内存空间。

2、方法即函数

在C语言中真正承载程序功能的就是一个个的函数，而在Java中则是一个个方法，这些个方法几乎和函数的使用一模一样。但是也是略有区别的。

例如java是有一种叫做构造方法，就是当对象在被创立的时候就被调用的方法，一般没有设定自定义的构造方法，我们呢就默认它是一个无参数的空方法，也就相当于什么都没有发生。但是一旦当我们设置了一些这种构造方法，而且还是有参数的构造方法的话，在一开始创立对象的时候，如果我们不输入参数进去，编译器就会报错。因为一旦我们设置了有参数的构造方法，原来的默认的无参数的空的构造方法就不存在了，所以我们一旦设置了又参数的构造方法就一定要主动地去设置自己的无参函数。

public class Example005 {
    public static void main(String args[]){
        Person s1 = new Person();
        s1.age = 18;
        s1.speak();
    }
}
class Person{
    int age;
    void speak(){
        System.out.println("我今年"+age+"岁");
    }
}

上面这个就是一个定义了一个Person的类，人然后在主函数中创立了具体的对象s1。然后我们调用了类中的一个方法。实现某些功能。

age就是Person类中的一个成员变量，speak（）就是一个成员方法，使用对象后面跟着成员变量的名字或者是成员方法就可以对变量就行修改和调用方法。

3、成员变量，局部变量，成员方法。

成员变量和局部变量的区别就是他们在整个类中所处的位置不同。前者在类内，方法外，后者在方法内。

但是您想，如果两个变量的定义重名了怎么办嘞？当如果我们想要在方法内把重名的两个变量进行赋值，我们就要使用一个关键字this。this的这个关键字就是可以指代本个类的成员变量。就好比是只要带个帽子修饰一下就可以区分本地居民和非法移民了（川普一定想有这种功能）。

类比于C语言局部变量就是函数中定义的变量，作用域只限于自己的函数内，同样的，方法的局部变量也是如此。

4、封装

java中为了防止别的类或者包的文件相互影响，改动数据，导致填入了不合理的数据，使用了private,default,protected,public等关键字来进行修饰来实现限制数据写入的功能。

这里主要以private来举例，一旦成员变量被private修饰，我们就不能在其他类中随意写入，修改这个成员变量，我们只能通过**set类名()和get类名()**等方式来来进行数据的写入和修改，前者进行对写入的新数据的判断和检查，然后在由后者写入原来的成员变量中去。

public class Example005 {
    public static void main(String args[]){
        Person s1 = new Person();
        s1.setAge(18);
        s1.setName("zzy");
        s1.speak();
    }
}
class Person{
    private int age;
    private String name;
    public int getAge(){
        return age;
    }

    public void setAge(int age) {
        if(age<=0){
            System.out.println("数据错误");
        }else {
            this.age = age;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    void speak(){
        System.out.println("我今年"+age+"岁"+",我叫"+name);
    }
}

这样一旦数据的改写不符合要求也不会将整个程序搞崩溃掉。在大型的软件的编写过程中真正地实现了各个开发模块的独立和尽量小的相互干扰。

5、重载

所谓重载就是对于一个方法有着多种类型，就像是七个葫芦娃，各有不同，但是都是葫芦娃而已，这个不同几乎是参数的类型或者参数的数量不同，这样我们就可以使用一个方法名编写多个不同共功能的方法了。

public class Example006 {
public static int add(int x,int y){
    return x+y;
}
public static int add(int x,int y,int z){
    return x+y+z;
}
public static void main(String args[]){
     int sum1 = add(1,2);
     int sum2 = add(1, 2 ,3);
    System.out.println("sum1 = "+sum1);
    System.out.println("sum2 = "+sum2);
}


}

上述这个add的方法就可以通过不同的参数个数来进行分享同一个方法名，当然也可以使用相当参数数量但是不同参数类型的共享方法，这也就是重载也可以算作是一种不冲突下的共享。

6、递归

递归就是方法内的自己调用自己，和C语言下的函数递归基本一致，下面是一个递归求和的程序。

public class Examle007 {
    public static int getsum(int n){
        if(n==1){
            return 1;
        }
        int temp=getsum(n-1);
        return temp+n;
    }

    public static void main(String[] args) {
        int sum = getsum(10);
        System.out.println("sum = "+sum);
    }
}

7、构造方法

构造方法就是以类本身命名的方法，如果不去定义的话，本来无参的构造方法就默认是空方法。如果定义了有参数的构造方法，就一定也要去定义。

public class Example008 {


    public static void main(String[] args) {
        Person1 p1 = new Person1();
    }
}
class Person1{
    public Person1() {
        System.out.println("已经调用了无参的构造方法");
    }
}

public class Example008 {


    public static void main(String[] args) {
        Person1 p1 = new Person1(18);
      p1.speak();
    }
}
class Person1{
    int age;
    public Person1() {
        System.out.println("已经调用了无参的构造方法");
        }

    public Person1(int n) {
         age = n;
    }
    public void speak(){
        System.out.println("我今年"+age+"岁了");
    }
}