Java语法核心——面向对象编程

目录

面向过程思想概述

面向对象思想概述

面向对象思想特点及举例

类与对象的关系

类的定义

类与对象的案例(demo02)

 对象内存存储机制

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

 private关键字

封装

扫描二维码关注公众号，回复： 17241082 查看本文章

​编辑

this关键字

​编辑

构造方法

​编辑 

标准类的代码写法和测试

 面向对象标准案例——学生类

面向过程思想概述

• 我们回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后再分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
• 在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
• 那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
• 面向过程的代表语言：C语言，汇编语言

面向对象思想概述

        当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

面向对象思想特点及举例

• 面向对象思想特点

        –是一种更符合我们思考习惯的思想

        –可以将复杂的事情简单化

        –将我们从执行者变成了指挥者

• 角色发生了转换
• 面向对象思想举例(demo01)

        –买电脑

        面向过程：我要买电脑——我要明确买电脑的意义——上网查对应的参数信息——去中关村买电脑——讨价还价——买回电脑

        面向对象：我要买电脑——班长去给我买电脑——买回电脑

        –洗衣服

        面向过程:把衣服脱下来——找一个盆——放点洗衣液——加点水——浸泡10分钟——揉一揉——清洗衣服——拧干——晾起来

        面向对象：把衣服脱下来——打开全自动洗衣机——扔衣服——按钮——晾衣服

类与对象的关系

• 我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
• 我们如何表示一个现实世界事物呢：

        –属性  就是该事物的描述信息

        –行为  就是该事物能够做什么

        –举例：学生事物

• 我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。

• 类：是一组相关的属性和行为的集合
• 对象：是该类事物的具体体现
• 举例：

        –类  学生

        –对象  班长就是一个对象

类的定义

• 现实世界的事物

        –属性  事物的描述信息（变量）

        –行为  事物能做什么（方法）

• Java中用class描述事物也是如此

        –成员变量  就是事物的属性

        –成员方法  就是事物的行为

• 定义类其实就是定义类的成员(成员变量和成员方法)

类与对象的案例(demo02)

• 学生类

        –如何定义

• 按照事物到类的过程一步步分析

        –如何使用

• 创建对象：

        –类名 对象名 = new 类名();

• 对象名.成员变量
• 对象名.成员方法（）

对象实际对应的是一个内存地址

学生类

类：Student.java

package com.demo02;
/**
 * 
 * @author 无限嚣张(菜菜)
 * 类的定义：类是用来描述现实世界的事务
 *事物：
 *		属性  事物的描述信息
 *		行为  事物能够做什么
 *类是如何和事物进行对应的？
 *		类：
 *			成员变量
 *			成员方法
 *需求：写一个学生类
 *学生事物：
 *		属性：姓名，年龄...
 *		行为：学习，吃饭...
 *学生类：
 *		成员变量：姓名，年龄
 *		成员方法：学习，吃饭
 *成员变量：和我们之前学的变量定义一样
 *		位置不同：类中，方法外
 *		初始化值：不需要给初始化值
 *成员方法：和我们之前学的方法是一样的，去掉static
 */
public class Student {
	//成员便令
	//姓名
	String name;
	//年龄
	int age;
	
	//成绩
	float score;
	
	//成员方法
	//学习方法
	public void study() {
		System.out.println("好好学习，天天向上");
	}
	
	//吃饭的方法
	public void eat() {
		System.out.println("学习饿了，要吃饭");
	}
}

主函数：StudentDemo.java

package com.demo02;
/*
学生类
        –如何定义

按照事物到类的过程一步步分析
        –如何使用

创建对象：
        –类名 对象名 = new 类名();

对象名.成员变量
对象名.成员方法
 */
public class StudentDemo {
	public static void main(String[] args) {
		//格式：类名 对象名 = new 类名();  s是学生类的对象
		Student s = new Student();
		System.out.println("s:"+s); //com.demo02.Student@193c0cf
	
		//直接输出成员变量值ֵ
		System.out.println("姓名："+s.name); //null
		System.out.println("年龄："+s.age); //0
		System.out.println("成绩："+s.score); //0
		System.out.println("----------");
		
		//给成员变量赋值ֵ
		s.name = "小花";
		s.age = 28;
		s.score = 65.5f;
		
		//再次输出成员变量值ֵ
		System.out.println("姓名："+s.name); //小花
		System.out.println("年龄："+s.age); //28
		System.out.println("成绩："+s.score); //0
		System.out.println("----------");
		
		//调用成员方法
		s.study();
		s.eat();
	}
}

结果演示

手机类 

创建类：phone.java

package com.demo02;
/*
 * 手机类
 * 		成员变量：品牌、价格、颜色
 * 		成员方法：打电话、发短信
 */
public class Phone {
	//品牌
	String brand;
	//价格
	int price;
	//颜色
	String color;
	
	//打电话
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
	
	//发短信
	public void sendMessage() {
		System.out.println("群发短信");
	}
	
	//发短信  方法重载
	public void sendMessage(String name) {
		System.out.println("给"+name+"发短信");
	}
}

package com.demo02;
/*
 * 手机类的测试类
 */
public class PhoneDemo {
	public static void main(String[] args) {
		//创建一个对象
		Phone p = new Phone();
		
		//输出成员变量值ֵ
		System.out.println("品牌："+p.brand);//null
		System.out.println("价格："+p.price);//0
		System.out.println("颜色："+p.color);//null
		System.out.println("------------");
		
		//给成员变量赋值ֵ
		p.brand = "华为";
		p.price = 2999;
		p.color = "红色";
		
		//再次输出成员变量值ֵ
		System.out.println("品牌："+p.brand);//����
		System.out.println("价格："+p.price);//2999
		System.out.println("颜色："+p.color);//��ɫ
		System.out.println("------------");
		
		//输出
		p.call("张三");
		p.sendMessage();
		p.sendMessage("小花");
	}
}

 对象内存存储机制

• 1个对象的内存

        –一个对象的基本初始化过程

• 2个对象的内存

        –方法的共用

• 2个对象的内存

        –两个引用指向同一个对象

1个对象的内存

前边已经创建类，我这里不再重复哈！

package com.demo03;

/*
 * 手机类的测试类
 */
public class PhoneDemo {
	public static void main(String[] args) {
		Phone p = new Phone();
		System.out.println("p:"+p);
		System.out.println(p.brand + "---" + p.price + "---" + p.color);
		
		p.brand = "华为";
		p.price = 2999;
		p.color = "红色";
		
		System.out.println(p.brand + "---" + p.price + "---" + p.color);
		
		p.call("张三");
		p.sendMessage();
	}
}

 2个对象的内存（两个不同的对象，不同的内存地址）

package com.demo03;
/*
 * 手机类的测试类
 */
public class PhoneDemo2 {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.brand = "小米5S";
		p.price = 1999;
		p.color = "银色";
		System.out.println("p:"+p);
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		p.call("张三");
		p.sendMessage();
		
		Phone p2 = new Phone();
		p2.brand = "IPhone7S";
		p2.price = 7999;
		p2.color = "土豪金";
		System.out.println("p2:"+p2);
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
		p2.call("林黛玉");
		p2.sendMessage();
	}
}

 3.两个引用指向同一个对象（内存地址和值完全一样）

package com.demo03;
/*
 * 手机类的测试类
 */
public class PhoneDemo3 {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.brand = "OPPO";
		p.price = 2999;
		p.color = "红色";
		System.out.println("p:"+p);
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		Phone p2 = p;			//把p的内存地址直接给了p2
		p2.brand = "华为";
		p2.price = 1999;
		p2.color = "黑色";
		System.out.println("再次输出p:"+p);
		System.out.println("p2:"+p2);
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
	}
}

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

• 在类中的位置不同

        –成员变量 类中方法外

        –局部变量 方法内或者方法声明上

• 在内存中的位置不同

        –成员变量 堆内存

        –局部变量 栈内存

• 生命周期不同

        –成员变量 随着对象的存在而存在，随着对象的消失而消失

        –局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

• 初始化值不同

        –成员变量 有默认的初始化值

        –局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

package com.demo04;

public class Variable {
	int x;//成员变量，有默认值
	
	public void show() {
		int y = 0;//局部变量，无默认值
		
		System.out.println(x);
		System.out.println(y);
	}
	
	public static void main(String[] args) {
		Variable variable = new Variable();
		variable.show();//类的方法
	}
}

 private关键字

• private关键字：

        –是一个权限修饰符。

        –可以修饰成员(成员变量和成员方法)

        –被private修饰的成员只在本类中才能访问。

• private最常见的应用：

        –把成员变量用private修饰

        –提供对应的getXxx()/setXxx()方法(get是获取age的值，set是给age赋值)

        –一个标准的案例的使用

类：

package com.demo05;

public class Student {
	String name;
	//int age;
	private int age;
	
	public void setAge(int a) {
		if(a<0 || a>200) {
			System.out.println("你给的年龄有误");
		}else {
			age = a;
		}
	}
	
	/*	public int getAge() {
			return age;
		}*/
	
	public void show() {
		System.out.println("姓名是："+name+",年龄是："+age);
	}
}

package com.demo05;

public class StudentDemo {
	public static void main(String[] args) {
		//创建类
		Student s = new Student();
		s.show();
		
		s.name = "张三";
		//s.age = 28;
		//s.age = -28;
		//s.setAge(-28);
		s.setAge(28);
		s.show();
	}
}

 小技巧：点击source——Generate Getters and Setters，自动生成get和set方法，根据需要做修改就可以了。

封装

• 封装概述

        –是面向对象三大特征之一。(其它两个是继承和多态）

        –是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

• 封装原则：

        –将不需要对外提供的内容都隐藏起来。

        –把属性隐藏，提供公共方法对其访问。

                •成员变量private，提供对应的getXxx()/setXxx()方法

• 好处：

        –通过方法来控制成员变量的操作，提高了代码的安全性

        –把代码用方法进行封装，提高了代码的复用性

类：

package com.demo06;
/*
 * 学生类
 */
public class Student {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

测试类：

package com.demo06;
/*
 * 学生类测试类
 */
public class StudentDemo {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		// 获取名字和年龄
		System.out.println(s.getName()+"——————"+s.getAge());
		
		// 给名字和年龄赋值
		s.setName("小花");
		s.setAge(48);
		System.out.println(s.getName()+"——————"+s.getAge());
	}
}

this关键字

• this:代表所在类的对象引用
• 记住：

        –方法被哪个对象调用，this就代表哪个对象

• 什么时候使用this呢?

        –局部变量隐藏成员变量

类：

package com.demo07;
/*
 * 学生类
 * 
 * 起名字我们要求做到见名知意
 * 而我们现在的代码中的n和a就没有做到见名知意，我们要改进
 * 
 * 如果有局部变量和成员变量名字相同时，在局部使用时，采用的是就近原则
 * 
 * 我们有没有办法把局部变量的name赋值给成员变量name呢？
 * 有
 * 
 * 什么办法呢?
 * 		用this关键字就可以解决这个问题
 * 
 * this:代表所在类的对象引用
 * 		方法被哪个对象调用，this就代表哪个对象
 * 
 * 使用场景
 * 		局部变量隐藏成员变量
 */
public class Student {
	private String name;
	private int age;
	
	public void setName(String name) { 
		//name = n;
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int age) {
		//age = age;
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
}

测试类

package com.demo07;
/*
 * 学生类
 */
public class StudentDemo {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		System.out.println(s.getName()+"---"+s.getAge());
		
		s.setName("张三");
		s.setAge(28);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

构造方法

• 构造方法作用概述

        –给对象的数据进行初始化

• 构造方法格式

        –方法名与类名相同

        –没有返回值类型，连void都没有

        –没有具体的返回值

• 构造方法注意事项

        –如果你不提供构造方法，系统会给出默认构造方法

        –如果你提供了构造方法，系统将不再提供

        –构造方法也是可以重载的

类:

package com.demo08;


public class Student {
	private String name;
	private int age;
	

	
	public Student() {}
	
	public Student(String name) {
		this.name = name;
	}
	
	public Student(int age) {
		this.age = age;
	}
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void show() {
		System.out.println(name+"---"+age);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

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

测试类

package com.demo08;

public class StudentDemo {
	public static void main(String[] args) {

		Student s4 = new Student("小花",28);
		s4.show();
	}
}

 

标准类的代码写法和测试

• 类

        –成员变量

        –构造方法

                •无参构造方法

                •带参构造方法

        –成员方法

                •getXxx()

                •setXxx()

• 给成员变量赋值的方式

        无参构造方法+setXxx()

        带参构造方法

类：

package com.demo09;
/*
 * 学生类
 */
public class Student {
	/**成员变量——姓名*/
	private String name;
	/**成员变量——年龄*/
	private int age;
	
	/**构造方法*/
	public Student() {}
	/**构造方法*/
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	/**给姓名赋值*/
	public void setName(String name) {
		this.name = name;
	}
	
	/**
	 * 获取姓名
	*/
	public String getName() {
		return name;
	}
	
	/**
	 * 给年龄赋值ֵ
	 * @param age
	 */
	public void setAge(int age) {
		this.age = age;
	}
	
	/**
	 * 获取年龄
	 * @return age
	 */
	public int getAge() {
		return age;
	}
}

测试类：

package com.demo09;
/*
 * 测试类
 */
public class StudentDemo {
	public static void main(String[] args) {
		//构造方法
		Student s = new  Student();
		s.setName("小花");
		s.setAge(28);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//赋值
		Student s2 = new Student("小花",28);
		System.out.println(s2.getName()+"---"+s2.getAge());
	}
}

 面向对象标准案例——学生类

类：student.java

package com.demo10;

public class Student {
	/**
	 * 学生类
	 */
	
	// 方法
	public void study() {
		System.out.println("好好学习");
	}
}

类：teacher.java

package com.demo10;

public class Teacher {
	/**
	 *调用学生类的学习方法 
	 * @param s 学生对象
	 */
	public void test(Student s,Yu d) {
		s.study();
		d.zy();
	}
}

类：yu.java

package com.demo10;

public class Yu {
	public void zy() {
		System.out.println("天天向上");
	}

}

测试类：

package com.demo10;

//需求：调用teacher的test方法

//类名作为形式参数
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = new Student();
		Yu q = new Yu();
		t.test(s,q);
	}
}

 类：

package com.demo11;

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

类：

package com.demo11;

public class Teacher {
	
	public Student getStudent() {
		Student s = new Student();
		return s;
	}
}

测试类

package com.demo11;

//需求：通过Teacher得到Student对象，然后调用Student类的方法
//如果方法的返回值是类名，其实返回的是该类的对象
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = t.getStudent();
		//Student s = new Student();
		s.study();
	}
}