JavaSE第六章、面向对象（上）

一、类与对象

• 类是一个数据量类型，如：Cat类。

• 类有属性，有行为。

• 对象就是一个具体的实例，如：老王的猫、老李的猫……

• 从猫类到对象，目前有几种说法：1.创建一个对象2.实例化一个对象……

public class test{
    public static void main(String[] args){
    	Cat cat1=new Cat();	//创建一个猫,并赋给Cat1.
    	cat1.name="小白";
    	cat1.age=1;
    	cat1.color="白色";
    	
    	System.out.println(cat1.name+" "+cat1.age+" "+cat1.color);
    }
}

class Cat{
    String name;
    int age;
    String color;
}

二、成员方法

修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;

}

public void cal(){
}
//public:公共类
//void：无返回值
//cal：方法名
//()内：形参列表
//{}内：方法体

方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

• 当方法返回一个值的时候，方法调用通常被当做一个值。

  eg：int larger = max(30, 40);

• 如果方法返回值是void，方法调用一定是一条语句。

  System.out.println("欢迎访问菜鸟教程！");

通过值传递参数

• 调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。

• 方法被调用后，实参的值并没有改变。

**递归调用 ***

//猴子吃桃问题
public class oop {
    public static void main(String[] args) {
        T t=new T();
        System.out.println(t.peach(1));
    }
}

class T{
    public int peach(int n) {
        if(n==10){
            return 1;
        }else if(n>=1 && n<=9){
            return ( peach(n+1)+1)*2;
        }else{
            System.out.println("无效日期");
            return -1;
        }
    }
}

//汉诺塔
public class HanoiTower {
    public static void main(String[] args){
        Tower tower=new Tower();
        tower.move(5,'A','B','C');
    }
}

class Tower{
    public void move(int num, char a, char b, char c){
        //若只有一个盘 num=1
        if(num == 1){
            System.out.println(a+"->"+c);
        }else{
            //若有多个盘，一律视为两个整体，最下面的盘（1）和上面的所有盘（num-1）
            //1.移动上面的盘 a->c->b
            move(num-1,a,c,b);
            //2.最下面的盘a->c
            System.out.println(a+"->"+c);
            //3.b上的所有盘b->a->c
            move(num-1,b,a,c);
        }
    }
}

三、overload

• 一个类的两个方法拥有相同的名字，但是有不同的参数列表。Java编译器根据方法签名判断哪个方法应该被调用。

• 重载的方法必须拥有不同的参数列表。不能仅仅依据修饰符或者返回类型的不同来重载方法。

四、可变参数

• 参数数量可变

• 将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

typeName... parameterName

在方法声明中，在指定参数类型后加一个省略号(...) 。

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数,个数可以是（0~n）。任何普通的参数必须在它之前声明。
• 使用可变参数时，可以当作数组来使用。(可变参数的本质就是数组)

public int sum(int... nums){
    System.out.println("nums.length");
    int res=0;
    for(int i=0;i<nums.length;i++){
        res+=nums[i];
    }
    return res;
}

五、作用域

• 方法内定义的变量被称为局部变量。

• 局部变量的作用范围从声明开始，直到包含它的块结束。

• 方法的参数范围涵盖整个方法。参数实际上是一个局部变量。

注意事项：

• 全局变量/属性可以加修饰符
• 局部变量不可以加修饰符

六、构造器/构造方法

• 当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

• 通常会使用构造方法给一个类的实例变量赋初值。

• Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同。一旦你定义了自己的构造方法，默认构造方法就会失效。

// 一个简单的构造函数
class MyClass {
  int x;
 
  // 以下是构造函数
  MyClass() {
    x = 10;
  }
}

public class test {
   public static void main(String[] args) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.x + " " + t2.x);
      //输出：10 10
   }
}

// 一个简单的构造函数
class MyClass {
  int x;
 
  // 以下是构造函数（有参数的构造方法）
  MyClass(int i ) {
    x = i;
  }
}

public class ConsDemo {
  public static void main(String[] args) {
    MyClass t1 = new MyClass( 10 );
    MyClass t2 = new MyClass( 20 );
    System.out.println(t1.x + " " + t2.x);
    //输出：10 20
  }
}

七、this

java虚拟机给每个对象分配this，代表当前对象。

访问成员方法的语法：this.方法名（参数列表）；
访问构造器的语法：this（参数列表）；⚠️只能在构造器内使用（即只能再构造器中访问另外一个构造器，且必须放在第一条语句。）

注意事项：

• this可以访问本类的属性、方法、构造器
• this用于区分当前类的属性和局部变量
• this不能在类定义的外部使用，只能在类定义的方法中使用

继承中会有更多this的细节。

//小练习：比较两个人是不是同一个人
public class thisTest {
    public static void main(String[] args) {
        Person p1 = new Person("mary", 28);
        Person p2 = new Person("tom", 18);
        System.out.println(p1.compare(p2));
    }
}

class Person{
    String name;
    int age;

    public Person(String name, int age){
        this.name=name;
        this.age=age;
    }

    public boolean compare(Person p){
        return this.name.equals(p.name) && this.age==p.age;
    }
}