6.面向对象，构造器,递归以及对象创建时内存分析（内含代码与练习）

面向对象的概念以及特征 概念 实质上将 "数据" 与 "行为" 的过程, 以类的形式封装起来, 一切以 对象 为中心的 面向对象的程序设计过程中有两个重要概念： 类（class）和对象 （也称为实例）。 其中类是某一批对象的抽象，可以把类理解成某种概念,相当于一种“模板”； 对象才是一个具体存在的实体，从这个意义上来看，日常所说的人，其实都是人的实例，而不是人类。 面向对象的特征 (1) 封装 (2) 继承   (3) 多态 类的定义 - -使用class修饰类 - -类用于描述某种概念，封装类的 静态特征以及动态特征 - -定义属性（成员变量、静态特征） - -定义动态特征（行为方法） 类与实例，实例对象的创建 - -类是抽象的 - -对象是真实存在的 - -对象的创建是通过类的 构造器new 出来的 - -引用类型有多少种？无数种

//定义一个person类，类中包括属性与方法
public class Person {
    	//属性
		String name;
		String sex;
		int age;
		void eat() {//无参数的eat方法
			System.out.println("干饭");}
		void sleep() {
			System.out.println("水饺");}
		void play() {
			System.out.println("玩");}
}

//创建对象，调用person类，初始化属性以及调用其方法
public class Object {
	public static void main(String[] args) {
		Person p;//创建 p 这个person类
		p=new Person();//初始化 p
		p.name="张三";//p的属性的初始化
		p.sex="男";
		p.age=77;
		System.out.println(p.name);
		System.out.println(p.sex);
		System.out.println(p.age);
		p.eat();//调用p 的eat方法
	}
}

package和import语句 全限定名 package+类名 package的 命名规则：一般为公司域名倒写/项目前缀；  例如：com.baidu.xxx（这里的xxx一般为某个模块/层次） 包名也为路径划分，例如：

//通过全限定类型约束当前类为com. day1027中的Person
com.day1027.Person p1 = new com.day1027.Person();

系统导入（import）

import  java.util.*;// 导入java.until这个包里的所有类
import  java.util.Arrays;//导入java.until这个包里面的Arrays类

1） 系统会默认导入同一个包中的类 2） 系统会默认导入java.lang.*; (可以在jdk/jre/lib/rt.jar中找到这个包) 位置关系 1）package语句在java源文件中的第一行 2）import语句在package和class之间 方法 基本组成 定义 - -用于封装某种特殊的功能操作，能够进行入参和返回数据

组成元素

修饰符， 方法返回值，方法名，方法参数，方法体

//定义一个方法，给某个小孩送礼物，要求获取姓名
public String songLiWu(String liwu){
    //public 为修饰符，String为返回值类型，songLiWu为方法名，String liwu为参数，｛｝包含的为方法体
	System.out.pringln("给小孩送了"+liwu);
	return "小明";
}

方法的语法 举例：我给水果店老板50元，老板要给我称50元的水果，然后把水果交给我（买水果） 修饰符 方法的返回值 方法名(方法的参数列表) { 方法体（买水果的过程） 收了我50元 称50元的水果 返回水果 }

有返回值

在调用方法后需要返回该类型的数据； 必须要加return语句。 --返回值类型为 基本数据类型（8种） 则需要注意，返回数据的 类型要比定义的返回值类型 小或者相等   比如：方法返回值类型为double  则可以返回比double类型小的数据（long、int......）  

	//两数相加的和，返回结果
	//如果返回值类型为基本数据类型，可以返回该类型所兼容的数据
	int add(int a,int b) {
		return a+b;
	}

--返回值类型为 引用类型 则返回该类型的 对象或者该 子类的对象

	//如果返回值类型为引用类型，可以返回该类或者该子类的对象数据
	Object buy(double money) {
		return 12;//自动装箱   基本数据类型装箱为Integer
	}

无返回值 使用void来表示当前方法没有返回值类型

//吃饭没有返回值类型
void eat() {
system.out.println( "吃饭");
}

方法签名 组成：由 方法名与 参数列表组成。（参数列表得看数据的 类型是否相同，若数据类型相同，但变量名不同，仍然为 同一个方法） 方法签名和修饰符、返回值类型没有关系。只要方法 签名不一致，则不是同一个方法

	//方法的id==方法签名--》【方法名+参数列表】
	int add(int a,int c) {
		return a;
	}
	int add(int a){//这两个方法并不是同一个方法
   		return a;
    }

练习 1、商品分类：Category 属性：--分类id--分类名称--商品列表   方法：用于获取当前商品分类最top的销量的商品的方法getTopSlaeProdution(); 2、商品：Prodution 属性：--商品编号--商品名称--商品价格--商品的总销量【销售额：元】   方法：用于打印当前商品的所有信息printMessage()

//商品分类Category
public class Category {
	// 属性：--分类id--分类名称--商品列表 
	int id;
	String name;
	Prodution[] produtions;

	// 方法：用于获取当前商品分类最top的销量的商品的方法getTopSlaeProdution();
	Prodution getTopSlaeProdution() {
		// 定义一个变量用于存放销量最高的商品
		Prodution top = produtions[0];
		// 遍历
		for (Prodution prodution : produtions) {
			// 判断，比较，把销量高的拿出来
			if (prodution.saleNum > top.saleNum) {
				top = prodution;
			}
		}
		// 返回销量最高的商品
		return top;
	}
    
//商品类Prodution
public class Prodution {
	// 属性：--商品编号--商品名称--商品价格--商品的总销量【销售额：元】
	int code;
	String name;
	double price;
	int saleNum;

	// 方法：用于打印当前商品的所有信息printMessage()
	void printMessage() {
		System.out.printf("当前商品编码%d，名称为：%s，价格:%f，销量%d n", code, name, price, saleNum);
	}
    
//测试类
    public static void main(String[] args) {
		// 调用getTopSlaeProdution方法，获取当前商品分类的最top的销量的商品,并显示该商品信息
		//主--商品分类    谓--调用    宾--getTopSlaeProdution方法      结果--销量的商品
		//1、创建多个商品
		Prodution p1 = new Prodution();
		p1.name = "秋裤";
		p1.saleNum = 100;
		Prodution p2 = new Prodution();
		p2.name = "卫衣";
		p2.saleNum = 1100;
		Prodution p3 = new Prodution();
		p3.name = "内裤";
		p3.saleNum = 10000;
		Prodution p4 = new Prodution();
		p4.name = "外套";
		p4.saleNum = 500;
		//2、创建商品分类、将多个商品赋值到商品分类中的列表
		Category category = new Category();
		category.name = "衣服";
		category.produtions = new Prodution[]{p1,p2,p3,p4};
		//3、调用方法
		Prodution top = category.getTopSlaeProdution();
		top.printMessage();//调用方法，显示商品信息
	}
    

方法的入参匹配

不同类型匹配的优先级（从高到低）

基本数据类型 本类型--> 类型的提升顺序 --> 本类型的包装类 -->本类型的可变长度类型 引用类型 本类型-->父类

//方法的入参匹配	
public static void main(String[] args) {
		// 方法调用按照方法签名来调用
		MethodInputInvoke invoke = new MethodInputInvoke();
		//方法调用--方法签名
		invoke.input(1,2);
		//基本数据类型：本身--》类型提升--》包装类型--》长度可变类型
		//引用类型：本身--》父类
		
		//在同一个类中，同一种行为的不同的体现
		//方法名相同，但是方法参数列表不同的	
	}

public class MethodInputInvoke {
	//方法的组成元素    修饰符  返回值类型 方法名 方法参数列表 方法体
	
	void input(Integer i) {
		System.out.println("Integer i----------------------------");
	}
	void input(Short i) {
		System.out.println("Short i----------------------------");
	}
	//参数入参个数是可变的 int...
	void input(int... i) {
		System.out.println("int... i----------------------------");
	}

重载方法的定义 1.同一个类中 2.方法名相同 3.参数列表不同 4.方法的重载和修饰符以及方法返回值是没有关系的，只跟方法签名有关系 练习 定义Hero类 这四个参数分别是 heroName（英雄名）， heroHP（英雄HP）， heroArmor（英雄攻击力）， heroMoveSpeed（移动速度） 互为重载方法： --自己治疗的方法heal【自己增加100HP】 --给一个队友治疗的方法heal【队友增加200HP】

//思路
//1.定义Hero类--定义属性--定义两个方法
public class Hero {
	// heroName（英雄名） heroHP（英雄HP） heroArmor（英雄攻击力） heroMoveSpeed（移动速度）
	String heroName;
	int heroHP;
	int heroArmor;
	int heroMoveSpeed;
	//--自己治疗的方法heal【自己增加100HP】
	void heal() {
		heroHP = heroHP+100;
	}
	//--给一个队友治疗的方法heal【队友增加200HP】
	void heal(Hero h) {//heal方法重载
		h.heroHP = h.heroHP+200;
	}	
}
//2.测试类--创建对象--调用方法--输出结果
public class HeroTest {

	public static void main(String[] args) {
		// 孙悟空治疗自己
		Hero sun = new Hero();
		sun.heroName ="孙行者";
		sun.heroHP = 1500;
		System.out.println(sun.heroHP);
		//
		sun.heal();
		System.out.println(sun.heroHP);
		// 小明治疗孙悟空
		Hero xiaoming = new Hero();
		xiaoming.heroName ="小明";
		//
		xiaoming.heal(sun);
		System.out.println(sun.heroHP);
	}
}

方法的递归 定义：一个方法重复调用自身。主要解决问题1、方法的出口 -2、递归的规律

练习

题目：古典问题：有一对兔子，从出生后 第3个月 起每个月都生一对兔子，小兔子长到第 三 个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？ 程序分析： 兔子的规律为数列1,1,2,3,5,8,13,21....； 求13个月后，如兔子都不死，兔子对数为多少

public class Raq {
	//方法   n表示为月份
	int growp(int n) {
		//1、出口
		if(n<=2) { //第一、二个月固定数量
			return 1;
		}else {
			//2、迭代    fum(n)= fum(n-1)+ fum(n-2)  当前月的数量等于前两个月的和
			return growp(n-1)+growp(n-2);
		}
	}
	
	//内部测试代码，要加static
    //外部测试代码则不用
	public static void main(String[] args) {
		//
		Raq ra = new Raq();
		//
		System.out.println(ra.growp(13));
	}
}

构造器的定义 定义 作用是创建对象。其最大用处就是在创建对象时执行初始化。构造器也是一个特殊的方法 ，因为构造器没有返回值类型
  构造器的语法   [修饰符]   类名(参数类别){ 方法体} 如果一个类中没有定义构造器，则系统会 默认提供一个 无参构造器，但是如果 有定义任意一个构造器，则系统 不再提供无参构造器，所以 通常来说在一类中 要有一个无参构造器和一个有参构造器。 （注意： 一般在类中定义构造器【无参和全参】【抽象类、接口、继承时会调用父类的无参构造器；在框架中会调用无参构造器】） 成员变量默认初始化 引用变量默认为 null  ； 基本数据类型默认为 0   ; 布尔类型默认为 false; 练习 现有： 班级： 班级编号、班级名、学生列表， 班主任， 班长 方法： 统计学生住址地点的方法，返回学生的住址地点

//分析：类--》属性--》方法--》测试
//班级Clazz--班级编号、班级名、学生列表，班主任，班长
//学生Student--姓名，住址地点

public class Clazz {
	//-- 班级编号、班级名、学生列表
	String code;
	String name;
	Student[] students;
	//--班主任
	Teacher teacher;
	//--班长
	Student monitor;
	
	public Clazz() {//无参构造器
	}
	public Clazz(String n,Student[] stus) {//有参构造器
		name=n;
		students=stus;
	}
	
	//统计学生住址地点的方法，返回学生的住址地点
	String[] getStuAddress() {
		//1创建一个数组，用于存放地址
		String[] adds = new String[students.length];
		//2遍历学生，把地址存放到adds中
		for(int i=0;i 
    
     
      
       
        
         
         

 
         
        
       
      
     
    
   
  
 
对象创建的内存分析 

 定义引用类型
 变量在main方法栈，而
 对象是在堆内存中创建的。
 

 初始化有默认值，赋值就是把默认值给覆盖了。
 

 方法只有调用的时候，才会入方法栈，用完便会释放出栈。