类和方法

类

1.概念

• java中没有结构体类型,类就是高度封装的结构体类型。还有c是面向过程的编程语言,而java是面向对象的,所以对数据的处理方式会有些不同,java中的类更适用于对数据的高度封装,适合调用。

• 类是具有相同特性（数据元素）和行为（功能）的对象的抽象。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。

• 类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。

• 类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。

2.类与类之间最常见的关系主要有以下3种。

• 依赖（或uses–a）。

• 聚合（或has–a）。

• 继承（或is–a）。

3.类的定义

格式

 public class 属性名(){
 	[修饰符] 属性类型 属性名 = [默认值] ;
 }

示例

public class People(){
    char sex;
    int tall;
    int age;
}

---

方法

1.概念

• 方法是指对象能够进行的操作，方法同时还有另外一个名称，叫做函数。方法是类中的定义函数，其具体的作用就是对对象进行描述操作。

• 方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。

• 面向过程中，函数是最基本单位，整个程序由一个个 函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

2.方法的定义

格式

[修饰符] 返回值类型 方法名(形参列表){
	// n 条语
}

示例

//无参数定义、调用
public static void main(String[] args) {
	Love();
}

public static void Love() {
    for (int i=1; i <= 3; i++) {
        System.out.println("I Love U!!!");
    }
}

//有参数定义、调用
public static void main(String[] args) {
	Love(3);  // 3实参
}


// n形参
public static void Love(int n) {
    for (int i=1; i <= n; i++) {
        System.out.println("I Love U!!!");
}

---

方法的重载

1.概念

​ 方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。

2.条件

• 不同的含义：形参类型、形参个数、形参顺序不同
• 只有返回值不同不构成方法的重载
• 只有形参的名称不同，不构成方法的重载

3.示例

public static void main(String[] args) {
    //根据判断调用方法
    add(3); 
    add(5,5);
}

public static void add(int n) {
    int sum = 0;
    sum = n + 100;
    System.out.println("和是： " + sum);
}
//定义重名方法
public static void add(int n,int m) {
    int sum = 0;
    sum = n + m;
    System.out.println("和是： " + sum);
}

// 运行结果
103 //调用一个参的add方法
10  //调用两个参的add方法

---

递归结构

1.介绍

程序调用自身的编程技巧称为递归（ recursion）。

• 递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己 调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

• 利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺 塔、快排等问题。

2.递归结构包括两个部分

• 定义递归头：什么时候不调用自身方法。如果没有头，将陷入死循环，也就 是递归的结束条件。

• 递归体：什么时候需要调用自身方法。

3.示例

​ 求n!

public static void main(String[] args) {
	System.out.println(factorial(10));
}

static long factorial(int n) {
    if (n == 1) {
    	return 1; //递归头
    } else {
    	return factorial(n - 1) * n;
    }
}

4.递归缺陷

​ 简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递 归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

5.注意事项

• 任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并 且易于理解和调试，并且不强调效率问题时，可以采用递归。
• 在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

---

类的实例化

实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = new 类名（参数1，参数2...参数n）构成。

public class 类和对象 {
    public static void main(String[] args) {
    	//实例化Person,也就是创建Person对象
        Person Student = new Person(); //声明一个Person类型的变量，变量名Student，实例化Person类，并给Student赋值的值就是当前的实例
        //new Person() 就是实例化Person类
 
        Student.name = "张三"; //类赋值
        Student.age = 18;
        Student.ShowName(); //调用类方法
        Student.ShowAge();
		System.out.println(Student.tall); //不赋值则为默认值0
        
        new Person().ShowName(); //匿名对象 
    }
}

class Person {
    String name;
    int age;
    String sex;
    int tall;

    public void ShowName() {
        System.out.println("姓名：" + name);
    } //方法 

    public void ShowAge() {
        System.out.println("年龄：" + age);
    } //方法 
}

// 运行结果
姓名：张三
年龄：18
0
姓名：null //匿名对象只为使用一次 不适合这种既赋值又调用的情况

---

构造器

每个类都至少有一个构造器

默认构造器的修饰符与所属类的修饰

一旦显式定义了构造 器，则系统不再提供默认构造器

一个类可以创建多个重载构造器

父类的构造器不可被子类继承

new 对象实际调用的是类的构造器

1.类的构造方法

默认

public class 类和对象 {
    public static void main(String[] args) {
        Person Student = new Person(); 
        //new Person() 调用的是public Person(){}方法
        
        Student.name = "张三"; 
        Student.age = 18;
        Student.ShowName(); 
        Student.ShowAge();
    }
}

class Person {
	
	public Person(){} //默认方法
	
    String name;
    int age;
    String sex;
    int tall;

    public void ShowName() {
        System.out.println("姓名：" + name);
    } //方法 

    public void ShowAge() {
        System.out.println("年龄：" + age);
    } //方法 
}

// 运行结果
姓名：张三
年龄：18

调用类并初始化

public class 类和对象 {
    public static void main(String[] args) {
    
        Person student=new Person();
        student.ShowName();
        student.ShowAge();
    }

}

class Person {
	// 定义了显示的类方法 就不会调用默认的方法（public Person(){}）
    public Person() {
        age = 20;
        name = "小二";
    } //每次调用类 age、 name 都是该值

    String name;
    int age;
    String sex;
    int tall;

    public void ShowName() {
        System.out.println("姓名：" + name);
    }

    public void ShowAge() {
        System.out.println("年龄：" + age);
    }
}

// 运行结果
姓名：小二
年龄：20

new对象并赋值

public class 类和对象 {
    public static void main(String[] args) {

        Person student = new Person(19, "王五");//实例化类并赋值
        student.ShowName();
        student.ShowAge();
    }
}

class Person {

    public Person(int n, String names) {
        age = n;
        name = names;
    } //带参数的方法

    String name;
    int age;
    String sex;
    int tall;
    
    public void ShowName() {
        System.out.println("姓名：" + name);
    }

    public void ShowAge() {
        System.out.println("年龄：" + age);
    }
}

// 运行结果
姓名：王五
年龄：19

2.构造方法重载

构造器也叫构造 方法，既然是方法，就可以重载。

• 方法名相同
• 方法的参数类型，参数个不一样
• 方法的返回类型可以不相同
• 方法的修饰符可以不相同
• main 方法也可以被重载

示例

public class 类和对象 {
    public static void main(String[] args) {

        Person Student = new Person(); //new对象对应 public Person() {}的构造器
        Student.name = "张三";
        Student.age = 18;
        Student.ShowName();
        Student.ShowAge();

        Person student = new Person(19, "王五");//对应带参数的构造器
        student.ShowName();
        student.ShowAge();

    }

}

class Person {

    public Person() {}
    public Person(int n, String names) {
        age = n;
        name = names;
    } //重名构造器

    String name;
    int age;
    String sex;
    int tall;

    public void ShowName() {
        System.out.println("姓名：" + name);
    }

    public void ShowAge() {
        System.out.println("年龄：" + age);
    }
}

// 运行结果
姓名：张三
年龄：18
姓名：王五
年龄：19