java1000个知识点之———面向对象

常用的两种编程思想

1.面向过程：
POP (Procedure Oriented)是一种以过程为中心的编程思想. 解决问题的方法与步骤
2.面向对象：
OOP (Object Oriented)是软件开发方法.面向对象方法，把相关的数据和方法组织为一个整体来看待 找"对象"解决问题。
.面向过程与面向对象：
1》解决简单问题时，使用面向过程。
2》解决复杂问题时，使用面向对象。
3》面向对象是以面向过程为基础的。
面向过程：

public class 猫捉老鼠面向过程版 {
	public static void main(String[] args) {
		seeMouse();
		mouseRun();
		catRun();
		getMouse();
	}
//	 ① 猫看见老鼠 。
	public static void seeMouse() {
		System.out.println("猫看见老鼠 。");
	}
//     ② 老鼠 跑
	public static void mouseRun() {
		System.out.println("老鼠 跑");
	}
//     ③ 猫 追逐老鼠
	public static void catRun() {
		System.out.println("猫 追逐老鼠");
	}
//     ④ 猫捉住了老鼠。 
	public static void getMouse() {
		System.out.println("猫捉住了老鼠。");
	}
}

面向对象：

public class 猫捉老鼠面向对象版 {
	public static void main(String[] args) {
		//有一只猫  一只老鼠
		Cat cat = new Cat();
		Cat cat1 = new Cat();
		Mouse  mouse = new Mouse();
		//功能：
		 cat.seeMouse();
		 cat1.seeMouse();
		 mouse.mouseRun();
		 cat.catRun();
		 cat.getMouse();
	}
}
//猫类： 抓特征： 
class Cat{
	//属性 (全局变量、成员变量、字段)：毛色 身高 体重 性别   "静态"特征
	String color;//毛色
	String name;// 姓名
	//方法：行为、功能、"动态"特征
//	 ① 猫看见老鼠 。
	public static void seeMouse() {
		System.out.println("猫看见老鼠 。");
	}
//    ③ 猫 追逐老鼠
	public static void catRun() {
		System.out.println("猫 追逐老鼠");
	}
//    ④ 猫捉住了老鼠。 
	public static void getMouse() {
		System.out.println("猫捉住了老鼠。");
	}
}
//老鼠类： 抓特征：
class Mouse{
//    ② 老鼠 跑
	public static void mouseRun() {
		System.out.println("老鼠 跑");
	}
}

类与对象

类

抽象的，一类具有共性特征的事物的抽象。就当模板 蓝图
关键字：class

创建对象

具体的事物。万物皆对象。
关键字：new

类中的成员

1》 属性： 成员变量 ，全局变量，类中方法外。
2》 方法/函数： 行为，功能。method
3》 调用成员：
对象.属性/方法名称(参数)

public class 类与对象 {
	public static void main(String[] args) {
		 Student st =new Student();
		 //属性： 对象.属性
		 st.name ="张三";
		 st.age =19;
		 st.display();
		 Student st1 =new Student();
		 //对象属性赋值为 李四  年龄为20
		 st1.name ="李四";
		 st1.age =20;
		 st1.display();
	}
}
class Student{
	String name;
	int age;
	public void display() {
		System.out.println(name + ":"+ age );
	}
}

对象的内存图

1.栈 ：stack :正在执行的方法。
局部变量，方法
2.堆 ：Heap : new 对象 ，有地址的
3.方法区：MethodArea ：类的信息、静态成员、常量池。
4.本地方法栈： 本地方法执行的栈。native ：本地方法。
5.程序计数器： 指令的执行。

对象创建

1.将对象的内存图.class加载到方法区。
2.查找其中的main方法开始进栈执行。
3.加载Person类到方法区，开辟p的空间。
4.以Person.class作为模板，在堆中创建出Person类的对象：
1》 属性 要在堆中的对象里开辟空间。进行默认初始化。
2》 方法不在
5.对象创建完毕，将地址值赋值给引用变量p，p就指向了Person对象。

对象创建赋值

6.通过p的引用变量，将Person对象 name和age的属性值赋值为张三，18.
7.调用Person类的display方法，该方法压栈，通过隐式指针，获取到name和age的值。
8.整个display方法执行完毕后，display方法弹栈，main继续执行，main方法也弹栈。
注意：
1》凡是new操作，必须开辟新空间，创建对象。
2》不同的对象，属性属于对象本身，其它对象不能修改

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

1.写法上(代码层次)：
成员变量： 在类中方法外
局部变量： 在方法中
2.内存上(位置)：
成员变量： 堆中 对象里
局部变量： 栈中 方法里
3.内存上(生命周期)：
成员变量： 随着对象的创建而创建，随着对象的消亡而消亡。
局部变量： 随着方法。
4.使用上(默认值):
成员变量：默认值：
基本数据类型：
byte short int long 0
float double 0.0
char ‘\u0000’
boolean false
引用数据类型：null
局部变量：没有默认值，先赋值再使用。

匿名对象

1.匿名对象：
没有名字的对象。
格式：
new 类名()

new Person().name="李四";
new Person().display();

注意：
① 匿名对象可以简化书写，但是匿名对象在进行方法/书写调用时，对于同一个对象来说，只能调用一次。
② 提高内存的利用率。

构造方法

1.Constructor: 构造方法 、构造器、构造函数。
作用：
① 用来创建对象的方法。实例化。
② 为对象的属性进行赋值。初始化。
2.格式：
[权限修饰符] 类名(){
}
注意：
1》构造方法中间没有返回值类型，无论是void还是数据类型都没有。
2》构造方法名称必须与类名相同。
3》如果一个类中没有显式的声明构造方法，编译器会为我们默认添加一个构造方法，无参空构造。
如果一个类中显式声明了构造方法，编译器不会为我们添加。
4》 构造方法的重载形式：
构造方法也有重载形式，参数可以是多个。

package com;
/**
    1.Constructor: 构造方法 、构造器、构造函数。
 *
 */
public class 构造方法 {
	public static void main(String[] args) {
		//A a = new A();
		A  b =new A(13);
		System.out.println(b.m);
	}
}
class A {
	int m;
	//构造方法的重载
	public A(){
	  System.out.println("这是一个构造方法。。。");
	}
	public A (int a) {
//		System.out.println("这是一个有参构造方法。。参数值为："+a);
		m = a;
	}
}

构造方法对属性的初始化问题

1.默认初始化： 开辟空间时初始化
2.显式初始化： 直接给属性进行赋值
3.构造初始化： 在构造方法中对属性进行赋值
这三种初始化，顺序如何？
默认初始化 --》 显式初始化 —》 构造初始化

public class 属性的初始化 {
	public static void main(String[] args) {
		A a =new A(20);
	}
}
class A{
	int m = 17;//属性
	public A(int m) {
		System.out.println("构造初始化之前，m的值为："+this.m);
		this.m = m;
		System.out.println("构造初始化之后，m的值为："+this.m);
	}
}