Java面向对象之类的设计

面向对象

类：对一事物是抽象的，概念上的定义

对象：是实际存在的该类事物的每个个体

面向对象程序设计的重点就是类的设计

设计类

其实就是设计类的成员

属性=成员变量=field=域，字段

方法=成员方法=函数=method

	package demo;
public class Person {	
	String name; 
	String sex;
	int age;
	
	public String say() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
}

类和对象的使用

面向对象思想落地的实现

1. 创建类，设计类的成员
2. 创建类的对象
3. 通过“对象.属性”或者“对象.方法”调用对象的结构

实例化说明

如果创建了一个类的多个对象，则每个对象都拥有一套独立的类属性（非static的）

意味着我们修改了一个对象的属性a,则不会影响另外一个对象属性a的值

//测试类
public class PersonTest {
	public static void main(String[] args) {
		//2. 创建Person类的对象
		Person p1 = new Person();
		//Scanner scanner = new Scanner(System.in);
		

		//调用对象的结构：属性、方法
		//调用属性：“对象.属性”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");
		
		//*******************************
		Person p2 = new Person();
		System.out.println(p2.name);//null
		System.out.println(p2.isMale);
		//*******************************
		//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
		Person p3 = p1;
		System.out.println(p3.name);//Tom
		
		p3.age = 10;
		System.out.println(p1.age);//10
		
	}

}

//1.创建类，设计类的成员
class Person{
	

	//属性
	String name;
	int age = 1;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("人可以吃饭");
	}
	
	public void sleep(){
		System.out.println("人可以睡觉");
	}
	
	public void talk(String language){
		System.out.println("人可以说话,使用的是：" + language);
	}

}

属性

属性（成员变量）VS局部变量

1. 相同点：

   1. 定义变量的格式：数据类型 变量名=变量值
   2. 先声明后使用
   3. 变量都有其对应的作用域

2. 不同点

   1. 在类中声明的位置不同

      ​ 属性：直接在定义类的一对{}里面

      ​ 局部变量：声明在方法体内，方法形参，构造器形参、构造器内部的变量

   2. 关于访问修饰符的不同

      ​ 属性：可以声明访问修饰符

      ​ 局部变量：不可以声明访问修饰符

   3. 默认初始化值不同；

      ​ 属性：类的属性，根据其类型，都有默认初始化值。

      ​ 整型（byte、short、int、long）：0

      ​ 浮点型（float、double）：0.0

      ​ 字符型（char）：0 （或’\u0000’）

      ​ 布尔型（boolean）：false

      ​ 引用数据类型（类、数组、接口）：null

      局部变量：没有默认初始值，意味着我们在调用局部变量之前一定要显示的赋值

      ​ 特别的形参在调用时我们赋值即可

   4. 在内存中加载的位置：

      ​ 属性：加载到堆空间

      ​ 局部变量：加载到栈空间

public class UserTest {
	

	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);
		System.out.println(u1.age);
		System.out.println(u1.isMale);
		
		u1.talk("韩语");
		
		u1.eat();
		
	}

}

class User{
	//属性（或成员变量）
	String name;
	public int age;
	boolean isMale;
	
	

	public void talk(String language){//language:形参，也是局部变量
		System.out.println("我们使用" + language + "进行交流");
		
	}
	
	public void eat(){
		String food = "烙饼";//局部变量
		System.out.println("北方人喜欢吃：" + food);
	}

}

方法

• public void eat(){} //无参无返
• public void sleep(int hour){} //有参无返
• public String getName(){}//无参有返
• public String getNation(String nation){}//有参有返

1. 方法的声明：权限修饰符 返回值 方法名（形参列表）{

   ​ 方法体

   }

   注意： static ,final,abstract来修饰的方法

2. 关于权限修饰符：默认方法的权限修饰符先都是使用public

3. 返回值类型： 有返回值VS无返回值

   ​ 有返回值则在方法声明是，指定返回值的类型，同事方法体中 需要使用return关键字来返回指定的类型的变量或者常量 “return 数据”

   ​ 无返回值则在方法声明时，使用void来表示，通常没有返回值是 在方法体中就不需要写return 如果一定要写那么这样定义“return;”来表示此方法结束

4. 方法名：属于标识符 遵循标识符的规则和规范 “见名知意”

5. 形参列表： 方法可以声明0个，1个，或多个形参。

6. return关键字的使用：

   ​ 使用范围：使用在方法体中

   • ​ 作用 ：结束方法
     • ​ 返回数据类型

注意： 方法中不可以定义方法，但是可以调用方法

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

		Customer cust1 = new Customer();
		
		cust1.eat();
		
		//测试形参是否需要设置的问题

//		int[] arr = new int[]{3,4,5,2,5};
//		cust1.sort();
		

		cust1.sleep(8);
		
	}

}

//客户类
class Customer{
	

	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("客户吃饭");
		return;
		//return后不可以声明表达式

//		System.out.println("hello");
	}
	

	public void sleep(int hour){
		System.out.println("休息了" + hour + "个小时");
		
		eat();

//		sleep(10);
	}
	

	public String getName(){
		
		if(age > 18){
			return name;
			
		}else{
			return "Tom";
		}
	}
	
	public String getNation(String nation){
		String info = "我的国籍是：" + nation;
		return info;
	}
	
	//体会形参是否需要设置的问题

//	public void sort(int[] arr){
//		
//	}
//	public void sort(){
//		int[] arr = new int[]{3,4,5,2,5,63,2,5};
//		//。。。。
//	}
	

	public void info(){
		//错误的

//		public void swim(){
//			
//		}
		

	}

}