JAVA类与对象

JAVA学习-04-韩顺平老师

JAVA-类与对象

01-类和对象的概念
类：类就是数据类类型,可以通过类来实例化多个具有相同属性的对象。
对象：对象就是类的一个具体的实例。
02-类属性
概念：属性是类的一个组成部分，一般是基本数据类型，也可以是引用数据类型。
注意事项：
1.属性的定义语法同变量，示例：访问修饰符（可选） 属性类型 属性名
2.属性的定义类型可以为任意类型。
3.属性如果不赋值，有默认值，规则和数组一致。
03-类的定义

public class Test {
	
	public static void main(String[] args) {
		
	}
}

class Person { // 创建一个类
	String name; // 属性
	int age;
	char gender;
	public void eat(){ // 方法
		System.out.println("我吃饭贼快");
	}
}

04-对象的定义

// 创建一个对象
public class Test {
	public static void main(String[] args) {
		Person p1 = new Person(); // 创建一个对象
		p1.name = "anyi"; // 给对象的属性赋值
		p1.age = 19;
		p1.gender = "男";
		// 调用方法
		p1.eat("香蕉"); // 我今天吃了香蕉 
	}
}

class Person { // 创建一个类
	String name; // 属性
	int age;
	char gender;
	/*
	方法的基本定义格式
	public 返回的数据类型 方法名 (参数列表) {
		语句
		return 返回值
	}
	*/
	public void eat( String fruit ){ // 方法
		System.out.println("我今天吃了" + fruit);
	}
}

05-方法调用详解
1.程序执行到方法时，会开辟一个独立的空间(栈空间)
2.当方法执行完毕后或者执行到return语句就会返回
3.返回调用方法的地方
4.继续执行后面的方法
06-方法调用的细节
1.同一个类中的方法可以直接调用，不需要声明类在调用
2.跨类中的方法A类调用B类的方法，需要通过对象名调用
3.跨类调用与方法的访问修饰符有关
07-成员方法的传参机制
1.基本数据类型的传参机制
注意细节：
-将实参传值给方法的形参，形参的改变不会影响实参
-演示：

public class Test {
	public static void main(String[] args) {
		Swap mySwap = new Swap();
		int a = 10;
		int b = 20;
		mySwap.change(a, b);
		System.out.println("\n执行玩change方法后\n a = " + a + "b = " + b );
	}
}

class Swap { // 创建一个类
	public void change( int num1, int num2 ){ // 方法
		System.out.println("\n变换前\n a = " + num1 + "b = " + num2 );
		int temp = num1;
		num1 = num2;
		num2= temp;
		System.out.println("\n变换后\n a = " + num1 + "b = " + num2 );
	}
}

2.引用数据类型的传参机制
注意细节：
-引用数据类型的传参是将地址传给了形参，使形参和实参指向同一个地址
-所以形参的改变会导致形参的改变
-演示：

public class Test {
	public static void main(String[] args) {
		Test t = new Test();
		int[] arrs = { 1, 2, 3};
		t.change(arrs); // 调用change方法
		System.out.println("调用change方法后：")
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + '\t'); // 结果 100  2  3
		}
	}	
}

class AA { // 创建一个类
	public void change( int[] arr ){ // 方法
		System.out.println("变换前：")
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + '\t'); // 结果： 1  2  3
		}
		arr[0] = 100;
	}
}

08-克隆对象

// 克隆对象
public class Test {
	public static void main(String[] args) {
		Person p1 = new Person(); // 声明一个Person的对象
		p1.name = "java";
		p1.age = 10;
		AA a = new AA(); // 声明一个AA的对象
		Person p2 = a.copy(p1); // Person类来接受返回的克隆对象，并赋值给p2
		if(p1 == p2) {
			System.out.println("两个对象相等！");
		} else {
			System.out.println("两个对象不相等！"); // 输出 ”两个对象不相等！“
		}
	}
}


class AA { // 创建一个类
	public Person copy(Person p){ // 方法
		Person newPerson = new Person();
		newPerson.name = p.name; // 复制对象的属性
		newPerson.age = p.age;
		return newPerson; // 返回克隆好的对象
	}
}

class Person {
	String name;
	int age;
}

09-方法重载
概念：java允许同一个类中，多个同名方法的纯在，但是要求参数列表不一致
好处：
-减轻了起名的麻烦
-减轻了记名的麻烦
注意事项：
-方法名：必须相同
-形参列表：必须不同(参数类型或者是顺序)
-返回类型：无要求

public class Test {
	public static void main(String[] args) {
		AA s = new AA();
		System.out.println(s.sum(1,2)); // 3
		System.out.println(s.sum(1,2,3)); // 6
	}
}


class AA { // 创建一个类
	int a;
	int b;
	public int sum(int a, int b) {
		return a + b;
	}
	public int sum(int a, int b, int c) {
		return a + b + c;
	}
}

10-可变参数
概念： java允许同一类中多个同名同功能但参数个数不同的方法，封装成一个方法。、
注意事项:
-可变参数的个数可以为0个或者任意多个
-可变参数的实参可以为数组
-可变的参数的本质就是数组

public class Test {
	public static void main(String[] args) {
		AA a = new AA();
		a.print(1,2,3);
	}
}


class AA { // 创建一个类
	public void print(int... nums) {
		System.out.println(nums.length); // 3
	}
}

11-作用域
基本使用:
1.在java变量中，主要的变量就是属性（成员变量）和局部变量。
2.我们说的局部变量一般指在成员方法中定义的变量。
3.作用域分为全局变量和局部变量。
4.全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
注意事项:
1.属性和局部变量可以重名，访问时遵循就近原则。
2.在同一作用域中，两个变量不能重名。
3.属性的生命周期长，伴随者对象的创建而创建，局部变量生命周期段，伴随者它的代码块的执行完毕而。
4.全局变量：可以在本类中使用。 局部变量：只能在本类对应的方法中使用。
5.全局变量可以加修饰符，局部变量不可以加修饰符。

public class Test {
	public static void main(String[] args) {
		AA a = new AA();
	}
}


class AA { // 创建一个类
	String name = "Peter"; // 全局变量
	public void print(int a, int b) {
		String name = "java"; // 局部变量
		System.out.println(name); // java 不带this就近原则
		System.out.println(this.name) // Peter 指明输出该对象的属性name
	}
}

12-构造器
基本概念：构造方法又叫构造器，是类的一种特殊方法，它的作用主要是完成新对象的初始化。
特点：
1.方法名和类名相同
2.没有范围值，同时也不能给 void
3.在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
注意事项：
1.一个类可以定义多个不同的构造器，即构造器重载。
2.构造器名和类名相同。
3.构造器没有返回值。
4.构造器是完成对象的初始化，并不是创建对象。
5.在创建对象时，系统自动的调用构造方法。
6.如果程序员没有定义构造器，系统自动的生一个无参构造方法
7.一旦定义了自己的构造器，默认的构造器就会被覆盖，就不能使用默认的构造器，除非显示定义。

public class Test {
	public static void main(String[] args) {
		AA a1 = new AA("jack", 20, "写代码");
		System.out.println("name = " + a1.name + "\tage = " + a1.age + "\thobby" + a1.hobby); // jack 20 写代码
		AA a2 = new AA("peter", 19);
		System.out.println("name = " + a2.name + "\tage = " + a2.age + "\thobby" + a2.hobby); // peter 19 null
	}
}


class AA { // 创建一个类
	String name; // 全局变量
	int age;
	String hobby;
	public AA(String name, int age, String hobby) { // 三个变量的构造器
		this.name = name;
		this.age = age;
		this.hobby = hobby;
	}
	public AA(String name, int age) { // 两个变量的构造器，构造器重载
		this.name = name;
		this.age = age;
	}
}

13-this
基本概念： java虚拟机会给每个对象分配一个this，代表当前对象
注意事项：
1.this关键字可以用来访问本类的属性，方法，构造器
2.this用于区分当前类属性和局部变量
3.访问成员的放的语法：this.方法名(参数列表)
4.访问构造器的语法：this(参数列表)，注意只能在构造器中使用
5.this不能在类的外部定义使用，只能在类的定义的内部使用

public class ThisDetail {
	public static void main(String[] args0) {
		Dog dog1 = new Dog("小黄", 2, "黄色");
		Dog dog2 = new Dog("小黑", 3, "黑色");
		dog1.info(); // 调用 dog1 的 info 
		System.out.println();
		dog2.info(); // 调用dog2 的 info
	}
}


class Dog { // 创建一个类
	String name; // 全局变量
	int age;
	String color;
	public Dog(String name, int age, String color) {
		this.name = name; // 使用 this 初始化 对象
		this.age = age;
		this.color = color;
	}
	public void info() {
		// 访问this属性，this执行该对象本身
		System.out.print("name = " + this.name + "age = " this.age + "color = " + this.color);
	}
}

类与对象小结，欢迎大家交流学习！！！