类与对象基础

类的定义与对象创建

首先创建一个类-Person

public class Person{ //定义人类具有三个属性，名字、年龄、性别
    String name; //直接在类中定义变量，表示类具有的属性
    int age;
    String sex;
}

创建一个实例对象，实例对象应该是一个具体的人：

new 类名();

public static void main(String[] args){
    new Person();//用new关键字来创建某个类的对象
}

对象的使用

我们可以使用一个变量来指代某个对象，只不过引用类型的变量，存储的是对象的引用，而不是对象本身

public static void main(String[] args){
//这里的a存放的是具体的某个值
    int a=10;
    Person p=new Person();
//这里的p存放的是对象的引用，而不是本体，我们可以通过对象的引用来间接操作对象
}

访问对象的一些属性，也就是在类中定义好的那些。对于不同的对象，属性具体存放值不同

public static void main(String[] args){
    Person p1=new Person();
    Person p2=new Person();
    p1.name="小杨";
    p2.name="小武"; //不同对象的属性是分开独立存放的，每个对象都有一个自己的空间
    p1.age=20;
    p1.sex="女";
    System.out.println(p1.name+" 年龄"+p1.age+" 性别"+p1.sex);
}

方法的创建与使用

首先是返回值类型，也就是这个方法完成任务后，得到的结果的数据类型

返回值类型 方法名称(){
    方法体……
}

如果没有返回值，只完成任务，用void表示没有返回值，如给人类编写一个自我介绍的行为：

public class Person{ 
    String name; 
    int age;
    String sex;
    void hello(){
    System.out.println("我叫"+name+"，今年"+age+"岁了！");
  }
}

p.hello()  //方法的调用

如果我们要让人类学会加法运算，可以通过定义一个方法的形式来完成：

int sum(int a,int b){ //这里需要两个int类型的参数进行计算
    int c=a+b;
    return c;//带返回值的方法，是一定要有一个返回结果的，否则无法通过编译！
}

注意：方法定义时编写的参数，我们一般称为形式参数，而调用方法实际传入的参数，我们称为实际参数

在使用return关键字之后，方法就会直接结束并返回结果，之后编写的任何代码都不可到达；

如果我们的程序中出现了分支语句，那么必须保证每一个分支都有返回值才可以

void test(int a){
    if(a==10) return;//如果a等于10，直接结束方法
    System.out.println("Hello World");//不是的情况就正常进行
}

参数传递问题：

void test(int a){  //我们可以设置参数来让外面的数据传入到函数内部
    System.out.println(a);
}

实际上参数的传递，会在调用方法的时候，对参数的值进行赋值，方法中的参数变量，不是我们传入的变量本身：

void swap(int a,int b){ //交换a和b的值
    int tmp=a;
    a=b;
    b=tmp;
}

public static void main(String[] args){
    Person p=new Person();
    int a=2,b=5;//外面也叫a和b
    p.swap(a,b);
    System.out.println("a="+a+",b="+b);
}

a与b的值并没有发生交换，交换的仅仅是方法中的a和b，参数传递仅仅是值传递，无法直接操作到外面的a和b

void modify(Person p){
    p.name="bob"; //修改对象的名称
}

public static void main(String[] args){
    Person p=new Person();
    p.name="amy";
    p.modify(p);
    System.out.println(p.name);
}

引用类型的变量，仅仅存放的是对象的引用，而不是对象本身。那么这里进行了值传递，相当于将对象的引用复制到了方法内部的变量中，而这个内部的变量，依然是引用的同一个对象，所以说这里在方法内操作，相当于直接操作外面的定义对象。

方法的进阶使用

public static void main(String[] args){
    Person p=new Person();
    p.name="bob";
    System.out.println(p.name);
}

void setName(String name){
    this.name=name; //让当前对象的name变量值等于参数传入的值
}

String getName(){
    return name; //这里可以不使用this
}

方法的重载

int sum(int a,int b){
    return a+b;
}

public static void main(String[] args){
    Person p=new Person();
    System.out.println(p.sum(10,20)); //计算两个整数的和
}

当我们使用小数时，参数要求是整数，程序会出现错误，为了让这个方法也能支持小数计算，我们可以将这个方法进行重载：

System.out.println(p.sum(1.2,2.5));

一个类可以包含多个同名的方法，但是需要的形式参数不一样，方法的返回类型可以相同也可以不同，但是仅返回值类型不同，是不被允许的：

int sum(int a,int b){
    return a+b;
}
double sum(double a,double b){
    return a+b;
}

方法之间是可以相互调用的：

void test(){
    System.out.println("我是test");
}
void say(){
    test(); //在一个方法内调用另一个方法
}

方法自己也可以调用自己：

void test(){
    test();
}

像这样自己调用自己的行为，我们称为递归调用，如果这样编写会出现栈溢出错误，但是可以给其合理的设置出口：如计算1加到n的和

int test(int n){
    if(n==0) return n;
    return test(n-1)+n; //返回的结果是下一层返回的结果，当前这一层的n
}