面向对象思想

A:什么是面向过程

面向过程,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。

B:什么是面向对象

面向对象思想就是不断的创建对象,使用对象,指挥对象做事情。(如果有对象,直接用对象,对我们直接提供服务)

面向过程特点与面向对象

A:面向过程:

强调的是过程,所有事情都需要自己完成

B:面向对象:

是一种更符合我们思想习惯的思想(懒人思想,我把事情自己不做,交给别人去做)

可以将复杂的事情简单化(对使用者来说简单了,对象里面还是很复杂的)

类与对象及其使用

类与对象概述

package com.Object;

/*
 * 
 * 我们是如何表示现实世界的事物的呢?
 * 		A:属性	就是事物的描述信息
 * 		B:行为	就是事物能够做什么
 * 		举例:学生
 * 
 * Java语言最基本的单位是类
 * 
 * 类:是一组相关的属性和行为的集合
 * 对象:就是该事物的具体体现
 * 		举例:
 * 			类		学生
 * 			对象		班长
 */
public class ObjectDemo {

}

类与对象案例

案例代码-学生类

package com.Object;

public class Student {
	// 成员变量
	// 姓名
	String name;
	// 年龄
	int age;

	// 成员方法
	// 学习的方法
	public void study() {
		System.out.println("好好学习,天天向上");
	}

	// 吃饭的方法
	public void eat() {
		System.out.println("学习饿了要吃饭");
	}
}
package com.Object;

/*
 * 需求:写一个学生类
 * 
 * 学生事物:
 * 		属性:姓名,年龄...
 * 		行为:学习,吃饭...
 * 
 * 学生类:
 * 		成员变量:姓名,年龄
 * 		成员方法:学习,吃饭
 *
 * 成员变量:和我们前面学习过的变量的定义是一样的。
 * 		位置不同:类中,方法外
 * 		初始化值:不需要给初始化值
 * 成员方法:和我们前面学习过的方法的定义是一样的。
 * 		去掉static关键字
 */
public class ObjectDemo2 {
	public static void main(String[] args) {
		// 格式:类名 对象名 = new 类名();
		Student s = new Student();
		// System.out.println("s:"+s); //com.itheima_02.Student@193c0cf
		// 直接输出成员变量值
		System.out.println("姓名:" + s.name); // null
		System.out.println("年龄:" + s.age); // 0
		System.out.println("----------");

		// 给成员变量赋值
		s.name = "张三林青霞";
		s.age = 33;

		// 再次输出成员变量的值
		System.out.println("姓名:" + s.name); // 林青霞
		System.out.println("年龄:" + s.age); // 28
		System.out.println("----------");

		// 调用成员方法
		s.study();
		s.eat();
	}

}

案例代码-手机类

package com.Object;
/*
 * 手机类:
 * 		成员变量:品牌,价格,颜色...
 * 		成员方法:打电话,发短信...
 */
public class Phone {
String logo;//品牌
int price;//价格
String color;//颜色

public void call(String name) {
	System.out.println("给"+name+"打电话");
}

//发短信
public void sendMessage() {
	System.out.println("群发短信");
}

}
package com.Object;
/*
 * 手机类的测试类
 */

public class PhoneDemo {
	public static void main(String[] args) {
		Phone iPhone = new Phone();// 创建手机对象
		System.out.println("品牌:" + iPhone.logo);// null
		System.out.println("价格:" + iPhone.price);// 0
		System.out.println("颜色:" + iPhone.color);// null
		System.out.println("------------");
		// 给成员变量赋值
		iPhone.logo = "Apple";
		iPhone.price = 6999;
		iPhone.color = "深空灰";
		// 再次输出成员变量值
		System.out.println("品牌:" + iPhone.logo);
		System.out.println("价格:" + iPhone.price);
		System.out.println("颜色:" + iPhone.color);
		System.out.println("------------");

		// 调用成员方法
		iPhone.call("雷布斯");
		iPhone.sendMessage();

	}
}

案例代码-成员变量和局部变量区别

package com.Object;
/*
 * 成员变量和局部变量的区别:
 * 		A:在类中的位置不同
 * 			成员变量:类中,方法外
 * 			局部变量:方法中或者方法声明上(形式参数)
 * 		B:在内存中的位置不同
 * 			成员变量:堆内存
 * 			局部变量:栈内存
 * 		C:生命周期不同
 * 			成员变量:随着对象的创建而存在,随着对象的消失而消失
 * 			局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
 * 		D:初始化值的问题
 * 			成员变量:有默认值
 * 			局部变量:没有默认值。必须先定义,赋值,最后使用
 */

public class VariableDemo {
	int x;
	public void show() {
		int y = 0;

		System.out.println(x);
		System.out.println(y);
	}

}

面向对象特性之封装

private关键字

  • 一个权限修饰符。
  • 可以修饰成员(成员变量和成员方法)
  • 被private修饰的成员只在本类中才能访问

案例代码-学生类

package com.Object_02;
/*
 * 学生类
 * 通过对象直接访问成员变量,会存在数据安全问题
 * 能不能不让外界的对象直接访问成员变量呢?
 * 如何实现呢?
 * 		private关键字
 * 
 * private:
 * 		是一个修饰符
 * 		可以修饰成员变量,也可以修饰成员方法
 * 		被private修饰的成员只能在本类中被访问
 * 
 * 针对private修饰的成员变量,我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
 */

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.Object_02;

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();
		}

}

private最常见应用

  • 把成员变量用private修饰
  • 提供对应的getXxx()/setXxx()方法

案例代码-老师类

package com.Object_02;

public class Teacher {
	private String name;
	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 setName(String a) {
		name = a;
	}
	
	public String getName() {
		return name;
	}
}
package com.Object_02;

public class TeacherDemo {
public static void main(String[] args) {
	Teacher teacher =new Teacher();
	teacher.getAge();
	teacher.getName();
	teacher.setAge(35);
	teacher.setName("张三");
	System.out.println(teacher.getAge());
	System.out.println(teacher.getName());
}
}

封装的概述和好处

  • 封装是面向对象三大特征之一,是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。
  • 封装原则:将不需要对外提供的内容都隐藏起来,把属性隐藏,提供公共方法对其访问,成员变量private,提供对应的getXxx()/setXxx()方法。
  • 通过方法来控制成员变量的操作,提高了代码的安全性把代码用方法进行封装,提高了代码的复用性。

this关键字

  • this:代表所在类的对象引用方法被哪个对象调用,this就代表那个对象
  • 局部变量和成员变量重名时使用

案例代码-this

package com.Object_02;

public class StudentThis {
	private String name;
	private int age;
	
	public void setName(String name) { 
		//name = name;
		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.Object_02;
/*
 * 学生类
 * 
 * 起名字要求做到见名知意。
 * 
 * 如果有局部变量名和成员变量名相同,在局部使用的时候,采用的是就近的原则。
 * 
 * 我们有没有办法把局部变量的name赋值给成员变量的name呢?
 * 有。
 * 
 * 什么办法呢?
 * 		用this关键字就可以解决这个问题
 * 
 * this:代表所在类的对象引用
 * 		方法被哪个对象调用,this就代表那个对象
 * 
 * 使用场景:
 * 		局部变量隐藏成员变量
 */

public class ThisDemo {
	public static void main(String[] args) {
		//创建对象
		StudentThis s = new StudentThis();
		System.out.println(s.getName()+"---"+s.getAge());
		
		s.setName("张三");
		s.setAge(23);
		System.out.println(s.getName()+"---"+s.getAge());
	}

}

面向对象之构造方法

构造方法

主要用来给对象的数据进行初始化

构造方法格式

  • 方法名与类名相同
  • 没有返回值类型,连void都没有
  • 没有具体的返回值

案例代码-构造方法

package com.Object_03;

public class Student {
	
	public Student() {
		System.out.println("这是构造方法");
	}
	
}
package com.Object_03;

public class StudentDemo {
	public static void main(String[] args) {
		//如何调用构造方法呢?
		//通过new关键字调用
		//格式:类名 对象名 = new 构造方法(...);
		Student s = new Student();
	}

}

构造方法注意事项与重载

  • 如果你不提供构造方法,系统会给出默认构造方法
  • 如果你提供了构造方法,系统将不再提供
  • 构造方法也是可以重载的,重载条件和普通方法相同

案例代码-构造方法的重载

package com.Object_03;

public class Teacher {
	int age;
	String name;

	public Teacher() {
		int age = 0;
		String nameString = null;

	}

	public Teacher(String name) {
		this.name = name;
	}

	public Teacher(int age) {
		this.age = age;
	}

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

	}

}
package com.Object_03;

public class TeacherDemo {
	public static void main(String[] args) {
		Teacher teacher1 = new Teacher();
		Teacher teacher2 = new Teacher(23);
		Teacher teacher3 = new Teacher("张三");
		Teacher teacher4 = new Teacher("李四", 22);
		System.out.println(teacher1.name + "-" + teacher1.age);
		System.out.println(teacher2.name + "-" + teacher2.age);
		System.out.println(teacher3.name + "-" + teacher3.age);
		System.out.println(teacher4.name + "-" + teacher4.age);
	}
}

类名作为形参和返回值

案例代码-类名作为形参

public class Student {
	public void study() {
		System.out.println("好好学习,天天向上");
	}
public class Teacher {
	public void test(Student s) {//接收传递过来的Student对象的地址值
		s.study();                  
	}
}
//需求: 调用Teacher的test方法

//类名作为形式参数:其实这里需要的是该类对象。
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = new Student();
		t.test(s);
	}
}

案例代码-类名作为返回值

public class Student {
	public void study() {
		System.out.println("好好学习,天天向上");
	}
}
public class Teacher {
	
	public Student getStudent() {
		Student s = new Student();
		return s;//返回的是Student对象的地址值
	}
}
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = t.getStudent();
		s.study();
	}
}