面向对象

面向对象

概述

面向过程：侧重分步骤
比如做菜：

1. 买菜,买各种食材,买各种调料
2. 开火,烧油
3. 翻炒
4. 出锅
   …

面向对象 : 侧重分类/模块
比如做菜：

1. 完成做菜,涉及到的事物有 : 厨师,食材,工具
2. 找个厨师,交给他
3. 厨师.买食材
4. 厨师.使用工具做菜

解决一个问题时，用面向对象的思想去思考问题，但实现具体的一个问题中的方法，一定是面向过程的。

构造方法

编译器功能 : 能把我们代码编译成class文件,并且还会检查代码的语法,也会帮助我们补全不规范的代码。
比如调用当前类中的静态变量的时候,可以省略类名,但是编译器会帮我们加上。同时如果我们类中没有构造方法,编译器也会默认帮我们创建一个公共的无参构造。
构造方法 :

1. 作用 : 创建当前类的实例化对象,初始化成员属性
2. 初始化 : 赋值
3. 静态变量什么时候初始化 : 类加载阶段(main方法执行之前)
4. 如果不定义构造方法的话,JVM会默认帮我们创建一个公共的无参构造
5. 如果我们定义了构造方法的话,不管我们定义的是有参还是无参,那么JVM都不会再帮我们默认创建无参构造
6. 构造方法默认是 : 公共的,静态的,没有返回值的,方法名和类名相同
7. 语法
   [权限控制修饰符] 类名(参数列表){方法体}

注：但是我们声明的时候 不能加static,因为构造方法具有双重性。

1. 如果 只是静态方法,那么 里面不能操作成员变量,也就不能对成员变量初始化赋值
2. 果 只是成员方法,那么就没有办法创建对象了,因为想要创建对象必须调用构造方法,而构造方法如果是成员的,想要调用成员方法必须先有对象。

所以 构造方法具有双重性,我们再声明的时候 不可以加static

public class _01_Constructor {
	public _01_Constructor(int i) {
		// TODO Auto-generated constructor stub
		
	}
	public _01_Constructor() {
		// TODO Auto-generated constructor stub
	}
	static int i;
	public static void main(String[] args) {
		//没有写任何构造方法，jvm对加载一个默认的构造方法
		_01_Constructor constructor = new _01_Constructor();
		
		//当自己写了一个有参的构造方法，建议再写一个无参的构造方法让声明对象时使用
		_01_Constructor constructor2 = new _01_Constructor(2);
	}
}

类和对象

在代码角度来说,类和对象都是保存数据的一种手段。

对象 :

1. 代码角度 : new 的一个实例,封装了特有的数据
2. 数据角度 : 封装数据和逻辑的一种方式
3. 现实角度 : 对象就是某一个具体的东西,一切皆对象
4. 设计角度 : 从一个实际的实体中抽象出来某些属性的一种实体表示

类 :

1. 概念 : 我们再思想上对某个事物/东西/某一类东西的唯一性标识
2. 是我们人,在思想上对某个事情/事物的一个界定(定义)
3. 是我们大脑对客观事物描述的一个标准,一个模板

我们再抽离某个概念,就能建立相关事物的类,一定通过他的数学来形成这个概念,通过这些属性来形成这个类，然后通过不同的属性值,形成了实体,就是那个具体的对象，通过不同的属性,划分不同的类,通过不同的属性值,划分不同的个体。

属性分为两种 :

1. 静态属性 : 类的行为和功能
2. 动态属性 : 类对象的行为和功能

实例化

实例化 :
类名 变量 = new 构造方法(参数);
实例化过程：

1. 加载类到静态区
2. 调用构造方法(栈内存压栈,开辟栈帧),在堆内存开辟内存空间
3. 把对应类中的成员属性复制到堆内存中
4. 再把堆内存内存地址赋值给栈内存遍历

对象使用

如定义一个Student类

public class Student {
	// 学号
	int id;
	// 姓名
	String name;
	// 性别
	boolean sex;
	// 年龄
	int age;
	// 住址
	String addr;
	
}

在其他类中使用Student类

	public static void main(String[] args) {
		// 创建一个Student类对象
		// 创建一个Student引用类型变量,取名为stu1, 保存的是堆内存对象的内存地址
		Student stu1 = new Student();
		// 输出的是stu1堆中保存的内存地址
		System.out.println(stu1);
		
		// 设置stu1的name属性值为张三
		stu1.name = "张三";
		// 获取stu1中的name属性值
		System.out.println(stu1.name);
		// 0
		System.out.println(stu1.id);
		// 0
		System.out.println(stu1.age);
		// null
		System.out.println(stu1.addr);
		// 上面我们只对name设置了值,没有设置值的变量,都有默认值(静态变量和成员变量都有默认值)
		// 整数为 0 , 小数 0.0 , 布尔 false , 字符 \u0000 , 引用 null

		// ----------------
		// 因为 stu1和stu2都是 Student类的实例化对象,所以 他们拥有相同的属性
		// 因为是新建的一个对象,在堆内存中是不同的内存空间,所以他们保存的值可以相同,可以不同,相互之间 没有影响
		// 创建一个student对象
		Student stu2 = new Student();
		// 设置stu2对象中的name属性值为李四
		stu2.name = "李四";
		// 获取stu2对象中的name属性值
		System.out.println(stu2.name);
	}

类的构成

类 : 根据具体的事物/需求，抽象出来的属性特征。

1. main : 入口方法,只要该类不是用来作为启动类的,就可以没有
2. 成员变量 : 每个对象共有的属性,属性值可以相同也可以不同
3. 静态变量 : 每个对象共有的属性和值(保存在方法区)
4. 局部变量
5. 成员方法
6. 静态方法
7. 构造方法
8. 抽象方法
9. 静态语句块
10. 动态语句块
11. this
12. super

类中只能出现这些,但是类中的一切都不是必须的,也可以什么都不写,但是如果写的话只能写这些

javaBean

在javaBean中，一切成员变量私有化，用于保护成员变量，提高代码的安全性，并且每一个成员变量有对应的get和set方法以及有参构造何无参构造。
如Student类：

public class Student {
	// 学号
	private int id;
	// 姓名
	private String name;
	// 性别
	private boolean sex;
	// 年龄
	private int age;
	// 住址
	private String addr;
	public Student(){
		
	}
	public Student(int id,
			String name,
			boolean sex,
			int age,
			String addr){
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.addr = addr;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean isSex() {
		return sex;
	}
	public void setSex(boolean sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getAddr() {
		return addr;
	}
	public void setAddr(String addr) {
		this.addr = addr;
	}
}

常见异常

1. 空指针异常：java.lang.NullPointerException
   在运行时报错，当使用null值(空的引用) 去访问成员属性的时候,就会出现空指针异常。
   如：

		Customer c = new Customer();
		c = null;
		System.out.println( c.getAge() );

2. 访问一个不存在的属性