07 面向对象

面向对象

面向对象

面向对象是一种编程思想

对象

万物皆对象
概念：在现实生活中真实存在的事物都叫做对象  

面向对象的编程思想

编程思想：用程序解决现实生活中需求的一种解决思路

面向过程的编程思想（C）：

面向对象的编程思想(java  python )：

面向过程：
把大象放冰箱总共分几步
	1.打开冰箱门
	2.把大象放进去
	3.关上冰箱门
面向对象：
	找到一个对象 街边卖煎饼的大妈
	大妈.做煎饼
	吃煎饼

类

概念： 类是一类具有相同特征的事物 将它们的共同特征抽取出来形成的一个概念  是不存在的

类和对象的关系：
类是对象的模版
对象是类在现实中的存在实例

怎么去定义一个类

这个事物长得什么样 看到的

这个事物具有什么功能行为 能干什么 

现实： java老师类
	属性：性别  年龄
    行为：教java  喝酒 

定义一个类：
	语法：
	class  类名｛
		//属性
		实例变量（成员变量）
		//行为
		成员方法	
	｝

总结：
	类中属性：实例变量进行描述
	类中的行为：成员方法进行描述

成员变量

概念：定义在类中方法外的变量叫做成员变量
位置：类中方法外
作用域：至少在本类
默认值：和数组中的数据类型的默认值一样
	整型：0
	浮点型：0.0
    字符类型：'\u0000'
    布尔类型：false
    引用类型：null
关于重名问题：
	1.成员变量之间不可以重名
	2.成员变量和局部变量之间可以重名 但是局部变量优先
为属性赋值：
	对象名.属性名 = 属性值；
访问对象的属性：
	对象名.属性名
案例：可以在定义一个类的同时为属性进行赋初始值
定义一个学生类
	属性：姓名  性别  年龄  学号
	行为：学习 撩妹子 打游戏  
public class Demo1{
	public static void main(String[] args) {
		//创建一个学生对象
		Student s1 = new Student();
		
		//访问s1对象的属性
		System.out.println(s1.name);

		//修改对象的属性值
		s1.name = "屎壳郎";
		//再进行访问
		System.out.println(s1.name);
			
	}
	
}

class Student{
	//属性
	String name = "二狗子";
	int age = 18;
	String sex = "女";
	String id = "007";

	//行为  成员方法
	public void study(){
		System.out.println("学习java  可以撩妹子了");
		
	}
	public void girlFriend(){
		System.out.println("我经常撩妹子。。");
		
	}

	public void playGame(){
		System.out.println("我天天打游戏 。。");
		
	}	
}

创建对象

语法：
类名  对象名 = new 类名();
案例：
public class Demo{
	public static void main(String[] args) {
		//创建一个老婆对象
		老婆  小冰 = new 老婆();
		//为对象的属性赋值
		小冰.name = "小范";
		小冰.sex = "女";
		小冰.age = 17;
		小冰.face = "肤白 貌美 大长腿";
		小冰.hight = 175.5;

		//访问对象的属性
		System.out.println(小冰.name);
		System.out.println(小冰.sex);
		System.out.println(小冰.age);
		System.out.println(小冰.face);
		System.out.println(小冰.hight);
		
	}
	
}


class 老婆{
	//属性
	String name;//姓名
	String sex ;//性别
	int age;//年龄
	double hight;//身高
	String face ;//外貌
	
}

成员方法

成员方法是用于描述一个类具有的行为
调用语法：
	对象名.方法名（）;
语法：
修饰符 返回值类型  方法名 (形参列表)｛
	方法的具体实现
｝

注意：
之前的函数定义语法：
public static 返回值类型 方法名（形参列表）｛
	方法的具体实现；
｝

成员变量和局部变量区别

	成员变量	局部变量
位置	类中方法外	方法内
作用域	至少本类	从定义行开始到所在的代码块结束
默认值	有	无
重名	成成之间是不可以重名的 成员变量和局部变量之间是可以重名的但是局部变量优先	在重合作用域范围内不可以重名

方法的重载

在一个类中 当同一种行为 它所需要的参数不同时 行为的方式也不同 我们可以将这种行为定义为同一个名字 系统根据参数的类型不同会自动的匹配行为 

java中 一个类的方法 它所需要的参数不同时其方法的实现也不同 我们将所有的方法定义为相同的名字 但是参数列表不同 这种现象叫做方法的重载

方法重载的要求：
	1.方法名相同 
	2.形参列表不同（个数  数据类型  顺序 ）
	3.和方法的修饰符返回值无关
案例：
定义一个数学计算的类

加法：
	1.两个整数的和
	2.两个小数的和
	3.3个整数的和
public class Demo1{
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = 30;
		double d = 12.5;
		double e = 35.8;

		//创建数学类对象
		ShuXue s = new ShuXue();
		//用数学类的对象 s 调用add方法
		int  result = s.add(a,b,c);
		System.out.println(result);
		
	}
	
}

class ShuXue{
	//加
	//整数的和
	public int add(int a,int b){
		System.out.println("计算两个整数的和 ");
		
		return a+b;
	}
	
	public double add(double a,double b){
		System.out.println("计算两个小数的和");
		return a+b;
	}

	public int add(int a,int b,int c) {
		System.out.println("计算3个整数的和 ");
		return a+b+c;
	}
	
	
}
==================================================================1.注意：方法的形参名不同但是 数据类型 个数  顺序都相同 不叫做方法的重载
案例：以下案例是错误的
public int add(int a,int b){
		System.out.println("计算两个整数的和 ");
		
		return a+b;
	}

public int add(int c,int d){
	return c+d;
}
==================================================================
2.当一个类中的方法 传入的实参和形参类型不完全匹配时 系统会根据实参的类型 向上就近匹配
byte short int long  float double 
案例：
public class Demo1{
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = 30;
		double d = 12.5;
		double e = 35.8;

		//创建数学类对象
		ShuXue s = new ShuXue();
		//用数学类的对象 s 调用add方法
		s.add(a,b);
		//System.out.println(result);
		
	}
	
}

class ShuXue{
	//加
	//整数的和
	/*public int add(int a,int b){
		System.out.println("计算两个整数的和 ");
		
		return a+b;
	}*/

	public double add(double a,double b){
		System.out.println("计算两个小数的和");
		return a+b;
	}
	public float add(float a,float b){
		System.out.println("计算两个float的数的和");
		
		return a+b;
	}
	public int add(int a,int b,int c) {
		System.out.println("计算3个整数的和 ");
		return a+b+c;
	}
}
=================================================================
3.当类中的方法和所传的实参的类型都不匹配时 一定会向上就近匹配 但是这种情况要避免匹配不明确
public class Demo1{
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = 30;
		double d = 12.5;
		double e = 35.8;

		//创建数学类对象
		ShuXue s = new ShuXue();
		//用数学类的对象 s 调用add方法
		s.add(a,b);
		//System.out.println(result);
		
	}
	
}

class ShuXue{
	//加
	//整数的和
	/*public int add(int a,int b){
		System.out.println("计算两个整数的和 ");
		
		return a+b;
	}*/
	public double add(int a,double b){
		System.out.println("int 和 double 的和");
		return a+b;
	}
	public double add(double a,int b){
		System.out.println("double 和 int 的和");
		return a+b;
	}
	public double add(double a,double b){
		System.out.println("计算两个小数的和");
		return a+b;
	}
	/*public float add(float a,float b){
		System.out.println("计算两个float的数的和");
		
		return a+b;
	}*/
	public int add(int a,int b,int c) {
		System.out.println("计算3个整数的和 ");
		return a+b+c;
	}
}
=================================================================
4.  int  int 
 1  int double
 2  float float
 原因：第一参数和方法一匹配  第二参数和方法2 比较匹配 
public double add(int a,double b){
		System.out.println("int 和 double 的和");
		return a+b;
} 
public float add(float a,float b){
		System.out.println("计算两个float的数的和");
		
		return a+b;
}
=============================================================
5.方法的返回值类型的定义 一定和方法实现的return后的返回值类型匹配
    public int add(int a,double b){
		System.out.println("int 和 double 的和");
		return a+b;
	}
============================================================
6.参数的顺序不同也叫方法的重载
public int add(int a,double b){
		System.out.println("int 和 double 的和");
		return a+b;
}
public double add(double a,int b){
		System.out.println("double 和 int 的和");
		return a+b;
}

构造方法（构造器）

构造方法是一种特殊的方法
特殊之处（特点）：
	1.构造方法的方法名和类名相同（包括大小写）
	2.构造方法没有返回值类型（连void都没有）
	3.构造方法可以重载
	4.构造方法只能在创建对象时自动调用一次
	5.构造方法不能手动调用 只能在创建对象时jvm自动调用
案例：
public class Demo1{
	public static void main(String[] args) {
		//创建学生对象
		Student s1 = new Student();
	}
}

//定义一个学生类 
class Student{
	//属性
	String name;
	int age;
	//定义一个构造方法
	public Student(){
		System.out.println("我被调用了");
		
	} 
	//成员方法
	public void study() {
		System.out.println("学习 java");
		
	}
}


案例：构造方法的重载
public class Demo1{
	public static void main(String[] args) {
		//创建学生对象
		Student s1 = new Student("屎壳郎");
	}
}

//定义一个学生类 
class Student{
	//属性
	String name;
	int age;
	//定义一个构造方法
	public Student(){
		System.out.println("无参构造被调用了");
		
	} 
	public Student(String s){
		System.out.println("有参的构造被调用");
		
	}
	//成员方法
	public void study() {
		System.out.println("学习 java");
		
	}
	
	
}

案例：构造方法只能被jvm在创建对象时 自动调用一次
Student s1 = new Student("屎壳郎");
s1.Student();//错误的

name-->null--->屎上飞--->屎壳郎--->屎留香
构造方法的作用：
	1.可以在创建对象的同时为对象的属性进行赋值
	2.用于创建对象 是由jvm自动调用
	3.为一个对象进行一些初始化的操作
===============================================================	
注意：当定义一个类的时候 如果没有定义构造方法 那么系统会为这个类默认提供一个公开的 无参的构造方法
案例:
public class Demo1{
	public static void main(String[] args) {
		//创建学生对象
		Student s1 = new Student();

		//s1.name = "屎留香";
		System.out.println(s1.name);
		
		
	}
}

//定义一个学生类 
class Student{
	//属性
	String name = "屎上飞";
	int age;
	
	//成员方法
	public void study() {
		System.out.println("学习 java");
		
	}
}


注意：当定义一个类时 也同时定义了有参的构造方法 那么系统就不再提供公开的无参的构造方法了
public class Demo1{
	public static void main(String[] args) {
		//创建学生对象
		//Student s1 = new Student("屎壳郎");
		Student s2 = new Student();//会报错
		//s1.name = "屎留香";
		//System.out.println(s1.name);
		
		
	}
}

//定义一个学生类 
class Student{
	//属性
	String name = "屎上飞";
	int age;
	
	public  Student(String s) {
		System.out.println("有参的构造");
		
	}
	
	
	
	//成员方法
	public void study() {
		System.out.println("学习 java");
		
	}
	
	
}

开发经验：
	当在开发时 定义一个类 如果同时定义了有参构造 那么我们也会同时定义一个无参的构造方法 避免在程序的运行中出错