2022.01.08_Java学习总结_面向对象_1_面向对象、构造方法、类和对象、实例化、Bean

1. 面向对象

1.1 概述

	面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件
开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智
能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

	面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次
来进行系统建模，更贴近事物的自然运行模式。

1.2 面向对象和面向过程

面向过程 : 侧重分步骤
比如要做一件事的时候,先进行分析
第一步应该做什么
第二步应该做什么
......
面向对象 : 侧重分模块
比如要做一件事的时候,分析出这件事应该交给谁去做


总结 : 
面向有对象优势 : 可扩展性,可维护性,灵活性,使程序耦合度降低
缺点 : 性能比面向过程相对较差

1.3 构造方法

	public static void main(String[] args) {
		// 静态属性调用
		// 类名.静态变量  / 类名.静态方法(参数)
		// 调用当前类中的静态属性,类名可以省略
		Contructor_01.m1();
		m1();
		// 成员属性调用
		// 对象.成员变量  / 对象.成员方法(参数)
		// 加前缀 是为了找到
		// 创建对象
		// new : 在堆内存创建对象空间
		// Contructor_01(); : 调用构造方法
		Contructor_01 c = new Contructor_01();
		c.m2();
	}

	public static void m1() {
		System.out.println("静态方法");
	}

	public void m2() {
		System.out.println("成员方法");
	}

* 构造方法 是每个类都有的,并且用于创建该类的对象
 * 
 * 如果 该类中 没有编写构造方法,那么 编译器会自动帮我们生成一个无参构造
 * 
 * 如果 该类中 编写了构造方法,不管写的是不是有参,则 默认的无参构造都不再自动生成
 * 		所以 当我们在写有参构造的时候,可以手动编写一个无参构造
 * 
 * 构造方法语法 : 修饰符   方法名/类名 (参数列表) { 方法体 }
 * 		构造方法的修饰符 我们只使用权限控制即可  , 不能使用static 
 * 		构造方法 没有返回值,连void都没有
 * 		构造方法的方法名 必须和类名一致

public class Contructor_02 {
	public static void main(String[] args) {
		// 自动调用构造方法
		Contructor_02 c = new Contructor_02();
	}

	public Contructor_02(int i) {
		System.out.println("构造方法");
	}

	public Contructor_02() {
		System.out.println("构造方法");
	}
}

1.4 类和对象

* 对象 : 
 * 		对象 就是某一个具体的事物
 * 
 * 类 : 描述了这一类事物的属性和特征,进行抽象出的模板 
 * 
 * 而 对象 就是类的实现,保存了属性的值
 * 
 * 在编程中,通过需求或者现实事物的属性和特征,来定义相关的类
 * 通过不同的属性值来定义不同的对象
 * 
 * 如果对象和对象之间 有相同的属性相同的值 就使用静态变量
 * 如果对象和对象之间 有相同的属性不同的值(也可以相同),就使用 成员

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

public static void main(String[] args) {
		// 创建一个学生对象
		Student s1 = new Student();
		// 成员变量赋值
		s1.name = "张三";
		//打印成员变量
		System.out.println(s1.name);
		}

1.5 实例化

 * 实例化 : 
 * 		1 加载对应类文件
 * 		2 new在堆内存创建空间
 * 		3 执行构造方法,对堆内存对象进行初始化
 * 		4 构造方法弹栈,并把堆内存地址返回给变量 student

public class OOP_02 {
	// int age ;
	// OOP_02(){
	// age = 2;
	// }
	public static void main(String[] args) {
		// 数据类型 变量名 = 值
		int i = 213;
		char c = 'a';
		// 变量
		Student student = new Student();
		// 字面量
		new Student();

1.6 对象使用

// 创建一个学生对象
		Student s1 = new Student();
		// 成员变量赋值
		s1.name = "张三";
		s1.age = 18;
		// 成员变量调用
		System.out.println(s1.name);
		System.out.println(s1.age);
		// 以下三个属性没赋值,则取默认值
		System.out.println(s1.id);
		System.out.println(s1.sex);
		System.out.println(s1.addr);
		
		// 再创建一个学生对象
		Student s2 = new Student();
		// null
		System.out.println(s2.name);

1.7 Bean

就是公共的类,私有化的属性,公共的获取属性的方法(getter/setter),公共的无参构造

public class User {
	private int id;
	private String username;
	private String password;
	private String nickname;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

1.8 常见异常

1.9 对象调用静态属性

// 静态属性 使用类名调用
		System.out.println(Student.i);
		// 也可以使用对象调用,在编译阶段 会把对象转换为类名调用,所以 该变量 是不是null 是没有关系
		System.out.println(student.i); // Student.i
		student = null;
		System.out.println(student.i); // Student.i

Student.i = 18;
		// 18
		System.out.println(Student.i);
		Student s1 = new Student();
		Student s2 = new Student();
		// 18
		System.out.println(s1.i);
		// 18
		System.out.println(s2.i);
		
		s2.i = 28;
		// 28
		System.out.println(s1.i);
		// 28
		System.out.println(s2.i);
		// 28
		System.out.println(Student.i);

1.10 注释事项

1.10.1 静态调用成员

public static void main(String[] args) {
		// 静态方法中,无法直接使用非静态属性
		// 需要使用对象调用才行
		// System.out.println(b);
		OOP_04 o = new OOP_04();
		o.b = 40;
		o.m1();
		// o.m2();
	}

	// 静态变量 : 对象之间共有的属性和值
	// 成员变量 : 对象之间共有的属性不同的值,但值也可以相等
	// 成员方法 : 方法中需要使用成员属性的时候,定义为成员方法
	// 静态方法 : 方法中不需要使用成员属性的时候,定义为静态方法
	public void m1() {
		System.out.println(b);
		System.out.println(a);
	}

1.10.2 传值和传引用

public class OOP_05 {
	public static void main(String[] args) {
		// int i = 10;
		// m1(i);
		// System.out.println("main->" + i);

		Animal a = new Animal(18);
		m2(a);
		System.out.println(a.age);
	}

	public static void m1(int i) {
		++i;
		System.out.println("m1->" + i);
	}

	public static void m2(Animal a) {
		a.age++;
		System.out.println(a.age);
	}
}

1.10.3 区分成员方法和构造方法

public class OOP_06 {
	public static void main(String[] args) {
		OOP_06 o1 = new OOP_06();
		// OOP_06 o2 = new OOP_06(15);
	}

	// 构造方法
	public OOP_06( ) {
		System.out.println("无参构造");
	}
	// 成员方法,成员方法可以和类名相同
	// 如何区分同名的成员方法和构造方法呢?  看返回值,构造方法没有返回值,void都没有
	public void OOP_06(int i) {
		System.out.println("有参构造");
	}
}