Java学习日记之07——面向对象方法

1.面向过程与面向对象的区别

面向过程方法

面向过程的方法我们需要分析事情怎么做，怎么用代码实现，每一步的操作都需要写出具体的操作与过程以完成需求。
但在实际的开发过程中，如果在编写过程中对每一步都进行编写的话，会导致代码数量的冗余，使代码的可阅读性和维护性下降。

面向对象方法

如果在编写过程中，把相似的步骤和功能进行封装，这样子整个代码的结构就清晰了很多，用的时候只需要调用相应的封装模块即可实现功能，这就是面向对象方法的概念。

2. 类，对象，成员变量和方法

类的定义

类是指具有相似属性和行为的实物，因此对类的定义包括其属性与行为，对应的就是成员变量和成员方法。
举例说明：

类名	学生
属性	姓名，年龄，性别，班级等
行为	吃饭，睡觉等

在JAVA中对其定义方法：

public class student {
	//定义成员变量即属性
	String name;   
	private int age;
	//定义成员方法即行为
	public void show() {
		System.out.println("姓名是："+name+"年龄是:"+age);
	}
	public void setAge(int a) {
		if(a<0||a>200) {
			System.out.println("你给的年龄有误");
		}
		age = a;
	}
	public int getAge() {
		return age;
	}
}

对象的定义

1.student是我们创建的一个类，如何才能够创建一个属于该类的对象呢？

创建对象的方法：在main方法中
类名 对象名 = new 类名（）
student s = new student()
即创建了一个属于student类的对象s.

2.如何使用类中的成员变量和方法呢？

对象名.成员变量
对象名.成员方法
如s.age s.getage即可使用student类中的成员变量和方法
s.age=18,为age赋值

3.对象的内存图

手机类的对象内存图

1.定义一个手机类

public class Phone {
	//成员变量
	String brand;
	int price;
	String color;
	//打电话
	public void call(String name) {
	System.out.println("给"+name+"打电话");
	
  }
	public void sendmessage() {
		System.out.println("群发短信");
	}
	
}

2.创建手机类对象及调用成员变量及方法

public class PhoneDemo {
	public static void main(String[] args) {
		Phone p = new Phone();
		System.out.println("品牌："+p.brand);
		System.out.println("价格："+p.price);
		System.out.println("颜色："+p.color);
		System.out.println("--------------");
		//给成员变量赋值
		p.brand="锤子";
		p.price=2999;
		p.color="棕色";
		System.out.println("品牌："+p.brand);
		System.out.println("价格："+p.price);
		System.out.println("颜色："+p.color);
		//成员方法
		p.call("林青霞");
		p.sendmessage();
		
	}
}

3.该过程的内存图

3.1.栈是电脑内存中加载出来用于处理系统操作的区域
3.2 堆储存所有new出来的内容
3.3 方法区存储所有方法
执行步骤：
1.加载main方法，phone p =new phone()，在堆中出现了一个new phone，它继承了phone构造方法中成员变量与成员方法，p指针指向new phone（）
2.输出brand，color，price，由于此时变量没有复制，因此string类型输出null，int类型输出0；
3.为成员变量赋值：将堆中的成员变量均进行赋值；
4.调用方法call与sendmessage，即调用堆中的成员方法，堆中的成员方法指向方法区。

4.对象共用方法区的内存图

1.手机类的定义与前文类似
2.对象的创建与成员变量与方法的调用

public class PhoneDemo2 {
		public static void main(String[] args) {
			Phone p = new Phone();
			p.brand="小米";
			p.color="银色";
			p.price=1999;
			p.call("林青霞");
			p.sendmessage();
			
			Phone p2=new Phone();
			p2.brand="iphone";
			p2.color="银色";
			p2.price=5999;
			p2.call("张曼玉");
			p2.sendmessage();
			
		}	

}

3.过程内存图

执行步骤：
1.加载main方法，新建一个new phone（），p指向new phone()，堆中成员变量单独存储，成员方法指向方法区。为堆中的成员变量赋值，并调用call和sendmessage方法。
2.再次新建一个new phone()，p2指向这一个new phone（），成员变量单独存储，成员方法指向方法区，调用call和sendmessage方法。
3.二者相互隔离

5.private关键字和封装

private关键字

如果不想让外部对象直接访问成员变量，使安全性得到保证，其方法是什么呢？
在类定义中，在成员变量前加入private关键字即可
如：private int age;外部对象就无法直接使用XX.age访问到类中的成员变量了。

通常情况下，在用private修饰以后，我们会给出setXXX与getxxx的方法来使外部对象自行定义成员变量值。
如在类定义中：
private int age;
public void setage(int a){
age = a;
}
public int getage(){
return age;
}
在对象引用中：
student s =new student （）;
s.setage(28);
s.getage;
而使用s.age无法进行赋值，会提示age字段不可视.

封装

封装是面向对象的三大特征之一。
封装的原则：
1.将不需要对外提供的内容隐藏起来
2.将属性隐藏，提供公共方法对其进行访问。
封装的好处：
1.提高代码的安全性
2.提高代码的复用性

6.this关键字

在给变量起名字的时候要做到简明知意，因此在定义成员方法时候，局部变量也需要做到这一点
在前面定义局部变量的时候，我们使用int a来定义局部变量。为了贯彻这个原则，需要改写为

public void setAge(int age) {
		age=age;

而实际过程中则会报错，这是为什么呢？因为变量的使用遵循就近原则，age=age等于把局部变量赋值给了局部变量，没有赋值给成员变量。
如何把局部变量赋值给成员变量呢？

public void setAge(int age) {
	 //age = age;
		this.age=age;

使用this.xx关键字，代表成员变量即可。

7.构造方法

构造方法的格式

构造方法如何写呢？
1.类名和方法名相同，大小写也要相同
2.没有返回值类型，连void也不要写

public student(){}
这是一个无参的构造方法

public student(int age){
	this.age = age;
}
这是有带参数的构造方法

构造方法是使用方法

类名 对象名 = new 构造方法(参数值)
如
student s = new student()；
student s = new student(18);
构造方法可以有多种，即构造方法是可以重载的。

8.实战练习:学生类的完整构造方法和使用

1.构造学生类

public class student{
	//成员变量
	private int age;
	private String name;
	//构造方法
	public student(){}
	public student(int age){
			this.age = age;
	}
	public student(String name){
			this.name = name;
	}
	public student(int age,String name){
			this.name = name;
			this.age = age;
	}
	//成员方法
	public void setname(String name){
			this.name = name;
	}
	public String getname(){
			return name;
	}
	public void setage(int age){
		this.age = age;	
	}
	public int getage(){
			return age;	
	}
}

2.使用学生类

public class studentDemo {
	public static void main(String[] args) {
		//无参构造
		student s = new student();
		s.setname("林青霞");
		s.setage(28);
		System.out.println(s.getage()+"___"+s.getname());
		//带参构造
		student s1 = new student(18,"林青霞");
		System.out.println(s1.getage()+"___"+s1.getname());
		
	}
}

9.类名作为形式参数和返回值类型

类名作为形式参数传递

1.student类
只有一个study成员方法

public class student {
	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

2.teacher类

public class teacher {
	public void test(student s) {
		s.study();
	}

3.调用test

public class test {
	public static void main(String[] args) {
		teacher t = new teacher();
		student s = new student();
		t.test(s);

student s作为形式参数传递到了test中

类名作为返回值类型

1.student类
同上
2.teacher类成员方法

public student getstudent() {
		student s = new student();
		return s;
	}

3.test方法调用

teacher t1 = new teacher();
student s1 = t.getstudent();
s1.study();