小学生学习Java的面向对象

面向对象

    理解：我该找谁干什么，重在对象，是指挥者，更贴近人的思维（懒人思维）

    面向对象的好处：  

        1.将复杂的问题简单化   

        2.从事物的执行者转化为事物的指挥者    

        3.更贴近人的思维    

类和对象

       java中最基本的单位就是类

       类: 对抽象事物的描述

       对象:用类创建出来的就是对象

举例：

// 当做学生类测试类
public class Demo {
	public static void main(String[] args) {
		//  创建一个学生类的对象
		//  类名 对象名 = 初值
		
		//  成员变量会随对象一起进入堆中
		//  new 一次就在堆中开辟一块内存空间
		//  Student stu 对象的引用(保存的对象地址)
		
		Student stu = new Student();
		Student stu1 = stu;
		//  使用 对象名.属性名 进行赋值和取值
		stu.name = "IT彭于晏";
		stu.age = 22;
		stu.gender = "男";
		// 调用成员方法 对象名.方法名()
		stu.eat();
		stu.playGame("王者荣耀");
		// 哪个对象调用该方法 打印的就是哪个对象 属性
		stu.say();
		
	}
}

class Student{
	// 属性(成员变量 实例变量) 
	// 书写位置：类中 方法外
	// 书写位置：类中
	String name;
	int age;
	String gender;
	
	// 成员方法/实例方法
	public void eat() {
		System.out.println("吃饭");
	}
	public void sleep() {
		System.out.println("睡觉");
	}
	public void playGame(String game) {
		System.out.println("打"+game);
	}
	// 介绍自己的方法
	public void say() {
		System.out.println("姓名"+name);
		System.out.println("年龄"+age);
		System.out.println("性别"+gender);
	}
	
}

成员变量 和 局部变量 的区别

  

  1.在类中位置不同：成员变量：在类中方法外。局部变量：在方法定义中或者方法声明上。

  2.在内存中的位置不同：成员变量：在堆内存。局部变量：在栈内存。

  3.生命周期不同：成员变量：随着对象的创建而存在，随着对象的消失而消失。局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

  4.初始化值不同：成员变量：有默认值初始化。局部变量：没有默认值初始化，必须定义，赋值，然后才能使用。

  5.作用域： 成员变量：整个类中    局部变量：在方法中

  6.注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。 

参数是基本数据类型和参数是引用数据类型

public class Demo {
	// 参数是基本数据类型
	public static void fun1(int a) {
		System.out.println(a);  // 100
		a = 10;
	}
	
	// 参数是引用数据类型
	// 要什么类型 就给什么类型
	public static void fun2(Person p) {
		p.name = "小姐姐";
		p.age = 18;
	}
	
	public static void main(String[] args) {
		int a = 100;
		fun1(a);
		System.out.println(a);  // 100
		
		Person p1 = new Person();
		p1.name = "小妹妹";
		p1.age = 18;
		fun2(p1);
		p1.say(); // 小姐姐 18
	}
}

匿名对象

    1.一般在方法传参数的时候使用

    2.只调用一下方法（不赋值的情况下）

public class Demo {
	
	public static void setNameAndAge(Person p,String name,int age) {
		p.name = name;
		p.age = age;
		p.say();
	}
	
	public static void main(String[] args) {
		// 创建两个person对象 并赋值
		// 将重复代码抽成一个方法
		Person p1 = new Person();
		p1.name = "小姐姐";
		p1.age = 16;
		p1.say();
		
		Person p2 = new Person();
		setNameAndAge(p2,"小姐",18);
		
		// 直接使用匿名对象 当方法参数
		// 好处：减少代码量
		setNameAndAge(new Person(),"小妹",18);
		
		// 匿名对象也是对象，也可以赋值属性 调用成员方法}}

封装

将数据或实现的细节隐藏内部的行为就是封装

封装特性不光体现在面向对象中，在面向过程中的提取方法的过程实际也是封装思想的体现

在面向对象编程中，如果我们不希望在类外访问成员变量或成员方法，可以将这些成员隐藏起，限制类外的访问，这种行为就是封装

如何实现封装

public，公有访问控制符  当使用该控制符时，成员变量即可以在类内使用，也可以在类外通过  对象名.成员变量  的方式使用

private，私有访问控制符  当使用该控制符，成员变量只能在类内访问

我们通常将成员变量定义为private，为其提供一对公有的get/set方法来使用成员变量，这种规范称为javabean规范

局部变量没有访问控制符

java bean 规范(java 实体类创建出来的对象)

 1.声明成员变量 都需要私有化

 2.给每一个成员变量提供 set/get 方法

 3.必须提供 无参的构造方法

举例：

public class Demo {
	public static void main(String[] args) {
		// 创建一个衣服cloth对象
		// 构造方法是系统帮你调的
		// 只要你创建对象 系统就会帮你调用构造方法
		// 构造方法 只会执行一便
		// 测试无参的构造方法
		Cloth p = new Cloth();
		p.say();
		
		// 测试有参的构造方法
		// 你传参数 系统就会去找你有参的构造方法
		Cloth p1 = new Cloth("T恤","白色");
		p1.say();
		
		
	}
}
class Cloth{
	
	 类中的书写顺序
	 1.成员变量
	 2.构造方法
	 3.成员方法
	 4.set/get方法
	 
	private String name;
	private String color;
	
	
	// 构造方法(无参)
	public Cloth() {
		// 初始化成员变量（给成员变量赋值）
		this.name = "夹克";
		this.color = "黑色";
		System.out.println("我是Cloth类的无参构造方法");
	}
	
	        // 有参的构造方法(构造方法的重载)
	        // 为了再创建对象的同时 给成员变量赋值
	public Cloth(String name,String color) {
		this.name = name;
		this.color = color;
		System.out.println("我是有参构造方法");
	}
	
	        // 介绍自己的方法
	public void say() {
		// 使用this 可以区分 成员变量 和 局部变量
		System.out.println(this.name + " " + this.color);
	}
	
	        // set 方法
	public void setName(String name) {
		this.name = name;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	
	        // get 方法
	public String getName() {
		return name;
	}
	
	public String getColor() {
		return color;
	}
}