Java 类和对象入门

类和对象基础

// 类和对象基础

/*

#步骤#
1.先编写类,包括属性和方法
2.创建对象: 
	先声明在创建: Cat cat1; cat = new Cat();
	直接创建: Cat cat2 = new Cat();
3.属性和方法的访问: 对象名.属性(方法)名
4.方法： 
	public void speak()
	访问方式 返回值 方法名 (参数){}


#注意事项#
1.类是抽象的, 对象是具体的, 类是对象的模板, 对象是类的一个实例
2.类中包括属性和方法
3.另一个对象等于另一个对象时, 二者指向相同的地址, 一个改变都改变, 
  对象名相当于地址
4.方法类中, 相当于函数, 需要先创建对象, 通过对象调用方法
  参数和返回值可以为任意类型, 返回多个值也可以返回数组或对象(引用传递)
  值传递不改变变量, 引用传递传地址会改变原参数(数组, 对象, 不包括String)
5.自己类中的方法直接调用即可(直接调用函数前要加static), 跨类调用要 对象.方法名, 若为 static 方法则可以通过 类名.方法名调用
值传递和引用传递
	值传递不改变变量, 引用传递传地址会改变原参数(数组, 对象, 不包括String)
	若在函数中把对象等于 null , 原对象不受影响, 因为传的是地址, 地址置空
	实参的类型若可以自动变换形参的类型也可以正常使用
*/

public class Test{
	public static void main(String[] args){
		People p1 = new People();
		p1.speak();
		p1.handsome(3);

		// 求和函数
		int a1 = 5;
		int a2 = 10;
		int b = p1.sum(a1, a2);
		System.out.println(a1 + "加" + a2 + "的和为" + b );

		// 参数数组和返回数组
		int[] A1 = {1, 2, 3, 4, 5};
		int[] B1 = {6, 7, 8, 9, 10};
		int[] ABsum = p1.getArrSum(A1, B1);
		System.out.println("A和B第一个数的和为" + ABsum[0]); // 输出7

		// 引用传递
		String s1 = "abc";
		System.out.println("调用函数前字符串为:" + s1);
		p1.gS(s1);
		System.out.println("调用函数后字符串为:" + s1);
	}
} 

class People{
	String name;
	int age;

	public void speak(){
		System.out.println("我是一个好人！");
	}
	public void handsome(int n){
		System.out.println("我大概有" + n + "个吴彦祖这么帅吧");
	}
	public int sum(int a, int b){
		int c = a + b;
		return c;
	}

	// 参数类型和返回值类型
	public int[] getArrSum(int[] A, int[] B){
  		int C[] = new int[5];
  		for(int i = 0; i < 5; i++){
  			C[i] = A[i] + B[i];
  		}
  		return C;
	}

	// 引用传递
	public void gS(String s){
		s = "456";
		System.out.println("函数中变换后为：" + s);
	}
}

方法的重载

/* 
方法的重载(方法同名,但形参个数,类型或返回类型不同)
1.可变参数用于多个数的求和(相当于传了一个数组)
	且若有多种参数,可变参数要放到最后,按顺序给前面的参数,剩余全为可变参数
	只能有一个可变参数

#构造方法#
类的一种特殊方法，完成对新对象的初始化
1.方法名与类名相同, 且没有返回值, 创建对象时自动调用构造方法
2.一个类可以有多个构造方法(重载, 形参不同)
3.若无构造方法, 系统会默认生成无参构造方法, 若已经写了构造器, 会覆盖无参构造方法
#this关键字#
4.java会给每个对象分配this, 代表当前对象(地址)
5.可通过 this. 调用属性和方法, 
6.通过this()调用构造器(只能在一个构造器中调用另一个构造器, 且必须写在首句)

*/

/*
#变量类型#
1.属性和局部变量(在本大括号内生效)
	属性在类中定义, 在类里生效
	局部变量定义在方法内,且必须赋初值,只在方法内生效
	属性与局部变量可重名, 但遵循就近原则
2.全局变量
	写在主函数外, 类内, 默认有初值
	可以加修饰符, 且可以被其他类通过对象调用
*/

public class Overload{
	public static void main(String arg[]){
		// 求多个数的和，可能为不同类型
		int a = 11;
		int b = 22;
		int c = 33;
		double d = 1.123;
		MyCalculator mc = new MyCalculator();
		System.out.println("两个整数的和为" + mc.calculator(a, b));
		System.out.println("整数和小数的和为" + mc.calculator(a, d));
		System.out.println("三个个整数的和为" + mc.calculator(a, b, c));

		// 可变参数的使用
		int a1 = 10;
		int a2 = 11;
		int a3 = 22;
		System.out.println("多个数的和为" + mc.sum(a1, a2, a3));

		// 构造方法创建对象
		Person p1 = new Person("神里绫华", 18);
		System.out.println("p1对象的属性为：" + p1.name + p1.age);
		// 使用this关键字
		p1.info();
		// 通过方法调用构造函数
		Person p2 = new Person();
		System.out.println("该对象名字为" + p2.name);
 	}
}

class MyCalculator{
	// 定义全局变量, 在本类中生效
	int ss = 1;

	// 求和
	public int calculator(int n1, int n2){
		System.out.println("全局变量ss的值为:" + ss);
		return n1 + n2;
	}
	public double calculator(double n1, double n2){
		return n1 + n2;
	}
	public int calculator(int n1, int n2, int n3){
		return n1 + n2 + n3;
	}

	// 可变参数
	public int sum(int... nums){
		System.out.println("数的个数为:" + nums.length);
		int ans = 0;
		for(int i = 0; i < nums.length; i++){
			ans += nums[i];
		}
		return ans;
	}
}

// 构造方法使用
class Person{
	String name;
	int age;
	// 不写void, 名称与类名相同, 括号内是形参
	public Person(String pName, int Age){
		System.out.println("Person构造方法被调用！");
		name = pName;
		// 使用this关键字代指该对象
		this.age = Age;
	}

// this指针的使用
	public void info(){
		// 通过this指针调用对象信息
		System.out.println("通过this输出姓名为:" + this.name);
		System.out.println("通过this输出年龄为:" + this.age);
	}
	// 通过this在构造器中调用另一个构造器
	public Person(){
		this("妮露", 18); 
		System.out.println("成功通过构造方法调用构造方法");
	}
}