详解面向对象

面向过程：我该干什么 重在过程 我是事物的执行者；

举例 ：挑选一台电脑

 1.挑一个CPU

 2.主板 华硕

 3.显卡

 4.显示器

面向对象：遇到事情想得是我应该找谁结局 重在对象 谁指的就是对象 我是指挥者；

例子：我要买个电脑

1.找个懂电脑的；

2.找个会砍价的；

3.找个会组装电脑的

面向对象的好处：

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

2.更接近人的思维 简单易理解

3.将复杂的问题简单化

类和对象

类：是一种抽象事物的表述；如梵高的画

对象：用类创建出来的就是对象 具体事物；

public static void main(String[] args) {

	//创建一个学生类的对象出来；

	//类名 对象名 = 初值；

	//成员变量会随对象进入堆中；

	//new 一次就在堆中开辟一块新空间；

	//Student stu 对象的引用 保存的是对象地址；

	Student stu = new Student();

	//使用 对象名.属性名 进行赋值和取值

	stu.name= "张毅";

	stu.age=22;

	stu.gender="男";

	//调用成员方法

	stu.eat();

	stu.playGame("刺激专场");

	stu.sleep();

	//那个对象调用该方法 打印的就是那个对象的属性

	stu.sayHi();

	

	Student stu1=stu;

}

}

class Student {

	//属性（成员变量 实例变量）书写位置：类中方法外

	//行为（方法）跟函数一样 就static 不写  书写位置：类中

	//思考：没给成员变量 初值 成员变量有没有值

	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("游戏");

	}

	//介绍自己的方法

	public void sayHi() {

		System.out.println("姓名:"+name);

		System.out.println("年龄:"+age);

		System.out.println("性别:"+gender);

	}

}

打印结果
姓名:张毅
年龄:22
性别:男

成员变量 和 局部变量 区别 

1.书写方式不同

成员变量：类中方法外

局部变量：类中方法内

2.内存标现

成员变量：堆内存

局部变量：栈内存

3.作用域

成员变量：整个类中

局部变量：方法中

4.生命周期：

成员变量：随着对象创建而进入堆中 随着对象销毁而销毁

局部变量：随着方法进入栈中 随着方法结束而销毁

5.初始值

成员变量：有初始值

局部变量：没有初始值初始化 必须 定义 赋值 才能使用

package com.lanou3g;

import java.awt.Color;

public class 对象Demo02 {
	public static void main(String[] args) {
		Car car = new Car();
		Car car2 = new Car();
		car2.setColor("无色");
		//出现错误是因为 color属性私有化了
		car.color="黑色";
		car.setColor("天蓝色");
		car.name="lamse";
		car.displacement="5.t";
		car.sayHi();
		car.stopCar();
		car.starCar(13);
	}
}
class Car {
	// 生名成员变量是可以给初值（初始化）；
	String name;
	String displacement;
	private  String color = "屎黄色" ;
	public void starCar(int a) {
		// 在 方法中 的 变量 是 局部变量；
		// 在 方法上 的 变量 是 局部变量
		int num = 10;
		// 就近原则
		//String color = "绿色";
		System.out.println(color);
		System.out.println("开车");
		System.out.println(num);
	}
	
	public void setColor(String color) {
			this.color = color;
	}

	public void stopCar() {
		System.out.println("停车");
	}
	//介绍自己方法；
	public void sayHi() {
		System.out.println("名字" + name);
		System.out.println("排气量" + displacement);
		System.out.println("颜色" + color);
	}
}

匿名函数

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

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

public class Demo05 {
	public static void setNameAndAge(Person p,String name,int age) {
		p.name=name;
		p.age=age;
		p.sayHi();
	}
	public static void main(String[] args) {
		//创建2个person对象 并赋值
		//将重复代码 抽成一个方法
		Person p1 =new Person();
		p1.name="wanglong";
		p1.age= 16;
		p1.sayHi();
		Person p2 =new Person();
		setNameAndAge(p2, "meng", 1);
		//使用匿名对象 当方法参数；
		//好处：减少代码量
		setNameAndAge(new Person(), "kun", 20);
		//匿名对象也可以 赋值属性 调用成员方法
		new Person().name="xin";
		new Person().age=30;
		new Person().sayHi();
		//只调用方法可以使用匿名对象
		//测试方法时可能使用；
		new Person().fun();
		
		
	}
}

封装

方法就是封装的一种；

相当于隐藏了代码的实现和属性 不能随意修改

需要开放访问的接口（方法）获取  修改

好处：

1.提高代码的复用性

2.提高代码安全性（不能随便修改）

private 私有的

被 private 修饰的属性 只能本类中访问

public class Demo06 {
	public static void main(String[] args) {
		Phone phone = new Phone();
		phone.setPhoneName("oppo");
		phone.setColor("黑色");
		System.out.println(phone.getPhoneName());
		System.out.println(phone.getColor());
	}
}

class Phone {
	//java bean 对象（java实体类创建出来的对象）
	//1.声明成员变量都需要私有化；
	//2.给每个变量提供一个get或者set方法；
	//3.必须提供 无参的构造方法；
	private String phoneName;
	private String color;
	//对外开放 访问方式
	//获取方法
	public String getPhoneName(){
		return phoneName;
	}
	//修改方法(设置方法)
	public void setPhoneName( String phoneName) {
		//就近原则
		//关键字 this 代表是 本类的对象
		//this.成员变量 获取本类的 成员变量
		//this.成员变量="hahah";给本类的成员变量赋值
		//this.成员方法 调用本类的成员方法；
		//谁调用了这个方法 谁就是this的指向
		 this.phoneName=phoneName;
	}
	//命名规范
	//获取 get + 成员变量名（首字母大写）
	//修改 set + 成员变量名（首字母大写）
	//set方法没有返回值
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color=color;
	}
	public void sayHi() {
		System.out.println(phoneName+" "+color);
	}
}

写10个类