5.面向对象-1

Pupper大约 5 分钟学习笔记Java基础

一、类

1. 属性

类的属性一般是基本数据类型，也可以是引用数据类型

注

属性的定义语法和变量的定语语法相同；
- 访问修饰符属性类型属性名；
属性如果不赋值，则默认值与数组一致；

class Cat{
    String name;
    int age;
}

2. 创建对象

class Cat{
    String name;
    int age;
}

// 先声明再创建
Cat cat;
cat = new Cat();

class Cat{
    String name;
    int age;
}

// 直接创建
Cat cat = new Cat();

二、方法

1.成员方法

访问修饰符 返回数据类型 方法名（形参列表）{
    方法体；
}

提示

访问修饰符：控制方法的使用范围，不写则默认
- 四种： public（公共的）、protected（受保护的）、default（默认）、private（私有的）
返回数据类型：可以返回任意类型；
- 如果有多个返回值时，可以封装成数组返回；
- void：表示没有返回值
方法名：遵守驼峰命名法的规则，首个单词的首字母小写，其他单词的首字母大写；
形参列表：参数的数量和类型不限制，参数调用时，参数类型必须相同或兼容
方法体：要执行的代码，方法不能嵌套使用；

注

法的调用：

同一个类中的方法可以直接调用
不同类之间调用方法时，需要用过类名调用；
- 对象名.方法名（参数）；
不同类之间方法的调用和方法的修饰符相关；

警告

注意：

引用类型传递的是地址，可以通过形参影响实参；
:::

public class demo01{
    public static void main(String[] args){
        Person p = new Person();
        p.speak();
        p.cal01();
        p.cal02(100);
        p.getSum(3,4);
    }
}

class Person{
    String name;
    int age;

    public void speak(){
        System.out.println("我是一个好人");
    }

    // 求 1~1000 之和
    public void cal01(){
    	int sum = 0;
    	for (int i=0; i<=1000; i++) {
    		sum += i;
    	}
    	System.out.println("1~1000 之和为："+sum);
    }

    // 求 1~n 之和
    public void cal02(int n){
    	int sum = 0;
    	for (int i=0; i<=n; i++) {
    		sum += i;
    	}
    	System.out.println("1~"+n+" 之和为："+sum);
    }

    // 求两个数之和
    public int getSum(int n,int m){
    	int res = n + m;
    	return res;
    }
}

2.递归方法

警告

注意：

如果递归方法中使用的是引用类型（比如数组、对象），就会共享该引用类型的数据；
递归必须向退出递归的条件逼近，否则就是无限递归
递归就是谁调用，就将结果返回给谁

public class demo01{
    public static void main(String[] args){
        T t = new T();
        int a = t.test(4);
        System.out.println(a);
    }
}

class T{
    public int test(int n){
    	if (n == 1) {
    		return 1;
    	}else{
    		return test(n-1)*n;
    	}
    }
}

public class demo01{
    public static void main(String[] args){
        T t = new T();
        int a = t.test(7);
        System.out.println(a);
    }
}

class T{
    public int test(int n){
		if (n < 3) {
			return 1;
		}else{
			return test(n-1) + test(n-2);
		}
    }
}

public class demo01{
    public static void main(String[] args){
        T t = new T();
        int a = t.test(1);
        System.out.println(a);
    }
}

class T{
    public int test(int day){
		if (day == 10) {
			return 1;
		}else{
			return (test(day + 1)+1)*2;
		}
    }
}

3. 方法重载

java 中允许同一个类中，多个方法同名，但是要求形参不一致

注意

注意事项：

方法名：必须相同
参数列表：必须不同
返回值：无要求

public class demo01{
    public static void main(String[] args){
    	MyCalculator myCalculator = new MyCalculator();

        System.out.println(myCalculator.calculate(3,4));
        System.out.println(myCalculator.calculate(3.3,4));
        System.out.println(myCalculator.calculate(3,4.4));
        System.out.println(myCalculator.calculate(3,4,5));
    }
}

class MyCalculator{
    public  int calculate(int n1, int n2){
    	return n1+n2;
    }
    public double calculate(int n1, double n2){
    	return n1 + n2;
    }
    public double calculate(double n1, double n2){
    	return n1 + n2;
    }
    public int calculate(int n1,int n2,int n3){
    	return n1+n2+n3;
    }
}

4.可变形参

java 中允许将同一个类中多个同名同功能但参数个数不用的方法，封装成一个方法

访问修饰符 返回类型 方法名（数据类型... 参数名）

提示

可变形参可以当做数组使用
可变参数的实参可以是数组
可变参数可以和普通类型的参数放在同一形参列表，并且可变参数需要放在最后
一个方法中只能有一个可变参数

public class demo01{
    public static void main(String[] args){
    	HspMethod hspMethod = new HspMethod();

        System.out.println(hspMethod.mySum());
        System.out.println(hspMethod.mySum(4));
        System.out.println(hspMethod.mySum(3,4));
        System.out.println(hspMethod.mySum(3,4,5));
    }
}

class HspMethod{
    public int mySum(int... nums){
    	if (nums.length > 1) {
    		int temp = 0;
    		for (int i=0; i<nums.length; i++) {
    			temp += nums[i];
    		}
    		return temp;
    	} else {
    		System.out.println("参数个数不足");
    		return -1;
    	}
    }
}

三、变量的作用域

全局变量：属性，作用域为整个类，可以不用赋值，有默认值局部变量：除了属性之外的其他变量，作用于代码块中，必须赋值，没有默认值属性和局部变量同名时，遵守就近原则属性可以被本类使用或者被其他类通过类调佣使用

class Cat{

	// 全局变量
	String name;
	int age;
	public void cat(){

		// 局部变量
		String color = "黑色";
	}
}

四、构造器

构造器：类的一种特殊方法，主要作用是对已经完成的新对象的初始化

[修饰符] 方法名（形参列表）{
    方法体；
}

提示

构造器的修饰符可以默认，也可以是其他的
构造器没有返回值
方法名与类名相同
在创建对象时，系统会自动调用该类的构造器完成对象的初始化
构造器也可以进行重载
如果没有定义构造器，系统会默认生成一个构造器
- 如： public Dog(){};
如果定义了构造器，默认的构造器会被覆盖，如果要调用默认的构造器，需要显示的重新定义一个

public class Demo{
    public static void main(String[] arge){
        // 通过构造器，直接给属性赋值
        Person p1 = new Person("张三", 20);
    }
}

public class Person{
    String name;
    int age;

    // 构造器
    public Person(String pName， int pAge){
        name = pName;
        age = pAge;
    }
}

五、this 关键字

this : 表示当前调用的对象

提示

this 关键字可以用来访问本类的属性、方法、构造器
- 访问成员方法： this.方法名（参数列表）
- 访问构造器：this（参数列表）；
  - 如果要访问构造器，语句必须放在第一条
  - 只能在构造器中使用（在构造器中访问另一个构造器）
this 用于区分当前类的属性和局部变量
this 不能在类定义的外部使用，只能在类定义的方法中使用

public class Person{
    String name;
    int age;

    // 构造器
    public Person(String name， int age){
        this.name = name;
        this.age = age;
    }
}

public class demo01{
    public static void main(String[] args){
    	Person p1 = new Person("张三", 15);
    	Person p2 = new Person("李四", 20);

    	System.out.println(p1.test(p2));
    }
}

class Person{

	String name;
	int age;

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

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