Java第五课. 类&对象

Java第五课. 类&对象

回顾

1.	冒泡:概念,实现:2个for循环分别起的作用
2.	二维数组可以理解成表格:有行有列,行当成一维数组,列当成一维数组中的元素,行有下标(几个一维数组),列也有下标(一维数组中的第一个元素)
3.	定义二维数组:  数据类型[][] 数组名=new 数据类型[行数][列数]

1. 类和对象

1.1 类的概念与作用

下表列出了面向对象与面向过程的具体区别:

	面向过程C	面向对象Java
设计思路	自顶向下、层次化、分解	自底向上、对象化、综合
程序单元	函数模块	对象
设计方法	程序 = 算法 + 数据结构	程序 = 对象 = 数据 + 方法
优点	相互独立，代码共享，性能高	接近人的思维方式 模拟客观世界，容易维护，扩展
缺点	数据与程序不一致 维护困难	客观世界的无序性 概念不成熟

面向对象的设计可以理解为:
将数据及对数据的操作封装在一起，成为一个不可分割的整体。
同时将具有相同特征的对象抽象成一种新的数据类型---类; 
通过对象间的消息传递使整个系统运转，通过类的继承实现代码重用。

概述:类就是一个模板,它是提供同一类对象的属性和方法.
举例子：
  世界杯比赛： 足球 球员  教练  裁判...
C罗:  姓名=C罗  身高 190  体重 150 性别:男    踢球(方法)
梅西:  姓名=梅西  身高 170  体重 130 性别:男    踢球(方法)

以球员为例:
	具有共同的属性:姓名,性别,身高,体重
	具有共同方法:踢球,射门,投球……..
类是描述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元，最基本的类由一组结构化的数据和在其上的一组操作构成。
               
将多个对象中公共的部分(只关注其中相同或者相似)提取出来(提取的过程，称为抽象);形成一个集合，这个集合，理解为一些对象的公共特征和行为，称为类; 
类是一个模板，是一个概念性模型，我们可以通过类，得到具体的对象:
分析的过程先有对象后有类,开发过程先有类后有对象;

创建对象的语法:
类型 引用名 = new 类名();

1.2 类中的基本构成元素

1.3 对象的概念与作用

概念:具体”明确”的属性值和方法的1个实体,对象是类的”实例”:实际的例子
举例子：
  世界杯比赛： 足球 球员  教练  裁判...
球员这个类可以实例化出哪些对象?
C罗:  姓名=C罗  身高 190  体重 150 性别:男    踢球(方法)
梅西:  姓名=梅西身高 170  体重 130 性别:男    踢球(方法)

在Java中万事万物皆对象(存在的可以被描述的任何事物)
现实生活中的对象:在座的各位都是对象,电脑,每一台电脑都是一个对象;
举例:
xx:个人基本信息(静态的描述)  23岁  性别男  爱好:吃
xx:个人基本信息(静态的描述)  26岁  性别男  爱好:睡觉

具体说:
个人特征称为:属性    行为称为:方法
对象=属性+方法
对象依赖于类存在（模板-个体实例）
分析过程先有对象后有类，但是开发过程先有类后有对象//重点
类型 引用名 = new 类名(); //

2. 类和对象的声明

2.1 类的基础声明形式

2.2 类名命名规范

1. 类的名字由大写字母开头而单词中的其他字母均为小写；如果类名称由多个单词组成，则每个单词的首字母均应为大写，把这些单词连接在一起，即不要使用下划线分割单词，例如:OrderList
2. 如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample
3. 由于类是设计用来代表对象的，所以在命名类时应尽量选择名词。 如上例的： Bike

2.3 类成员属性的声明、初始化与初始值

/**
 * 这个学生类是一个自定义类,这个类会有学生的特征:学号,姓名,班级,性别等
 * 动作:学习,玩  玩手机  打游戏 敲代码,换装
 * @author Administrator
 *
 */
public class Student {
    
	//特征也可以称为属性
	//属性的语法:  修饰符 数据类型 变量名=值;
	String stuNo;
	String stuName;
	int age;
	
	//这个人会有行为(动作)->方法
	//方法的语法:
	/*访问修饰符  修饰符 返回值的数据类型(void 无返回值) 方法名(参数列表){
		
	}*/
	public static void main(String[] args) {}
	
	//普通方法
	public void play() {
		System.out.println(stuName+"在玩手机~");
	}
	
}

2.4 实例化类的对象

2.41 new 运算符

new 是“为新建对象开辟内存空间”的运算符；它以类为模板，开辟空间并实例化一个对象，返回对该对象的一个引用（即该对象所在的内存地址）;

类名  引用名 = new 类名();
类名  引用名 = new 类名(参数);
测试类:

/**
 * 类是一个模板,是一种概念性的模型,我们可以通过类,得到具体的对象
 * 类型 引用名=new 类型();
 * @author Administrator
 *
 */
public class TestStudent {
	public static void main(String[] args) {
		//类型 引用名(对象名)=new 类型();
		Student stu1=new Student();
		//给某个对象的属性赋值
		//语法:对象名.属性/方法
		stu1.stuNo="001";
		stu1.stuName="小明";
		stu1.age=23;
		
		stu1.play();
		
		//再创建一个对象
		Student stu2=new Student();
		//给某个对象的属性赋值
		//语法:对象名.属性/方法
		stu2.stuNo="002";
		stu2.stuName="小华";
		stu2.age=26;
		stu2.play();
	}

}

2.5 类和对象关系与区别

	类是同等对象的集合与抽象。它是一块创建现实对象的模板。对象是类的实例，对象是面向对象编程的核心部分，是实际存在的具体实体，具有明确定义的状态和行为。

练习:自定义一个pig类,这个类中包含了属性和方法
/**
 * 自定义一个猪类
 * @author Administrator
 *
 */
public class Pig {

    //属性
	String name;
	int weight;
	
	/**
	 * 吃的方法
	 */
	public void eat() {
		System.out.println(name+"在吃汉堡");
	}
	/**
	 * 介绍
	 */
	public void showInfo() {
		System.out.println("我是"+name+",我的体重"+weight+"kg");
	}
}

测试类:

public class TestPig {

	public static void main(String[] args) {
		// 创建猪类的对象
		Pig pig=new Pig();
		//调用属性
		pig.name="八戒";
		pig.weight=200;
		
		//调用方法
		pig.eat();
		pig.showInfo();
		
		//再创建一个对象
		Pig pig2=new Pig();
		//调用属性
		pig2.name="佩奇";
		pig2.weight=200;
		
		//调用方法
		pig2.eat();
		pig2.showInfo();

	}

}

八戒在吃汉堡
我是八戒,我的体重200kg
佩奇在吃汉堡
我是佩奇,我的体重200kg

可以这样改:
/**
 * 自定义一个猪类
 * @author Administrator
 *
 */
public class Pig2 {

    //属性
	String name;
	int weight;
	
	/**
	 * 吃,能不能不是所有的对象都吃同样的事物?需要给这个方法增加一个参数
	 * @param food 参数,表示的是方法要正常执行的"前提条件"
	 */
	public void eat(String food) {
		System.out.println(name+"在吃"+food);
	}
	/**
	 * 介绍
	 */
	public void showInfo() {
		System.out.println("我是"+name+",我的体重"+weight+"kg");
	}
}

测试类:
public class TestPig2 {

	public static void main(String[] args) {
		// 创建猪类的对象
		Pig2 pig=new Pig2();
		//调用属性
		pig.name="八戒";
		pig.weight=200;
		
		//调用方法
		pig.eat("人参果");
		pig.showInfo();
		
		//再创建一个对象
		Pig2 pig2=new Pig2();
		//调用属性
		pig2.name="佩奇";
		pig2.weight=200;
		
		//调用方法
		pig2.eat("草莓蛋糕");
		pig2.showInfo();

	}

}

八戒在吃人参果
我是八戒,我的体重200kg
佩奇在吃草莓蛋糕
我是佩奇,我的体重200kg

2.6 方法的基本声明形式

2.7 类中方法的定义:普通方法

2.71 目的

提取共同的代码块放在一个方法内，可以被重复的调用。

2.72 方法类型

无参数无返回值方法
有参数无返回值方法
有参数有返回值方法
无参数有返回值方法

import java.util.Scanner;

/**
 * 定义方法求2个数中最大值
 * @author Administrator
 *
 */
public class TestMethod02 {
	Scanner scanner=new Scanner(System.in);
	
	//1.有参数有返回值
	public double getMax(double a,double b) {
		return a>b?a:b;		
	}
	
	//2.无参数无返回值
	public void  getMax2() {
		System.out.println("请输入2 个数:");
		double a=scanner.nextDouble();
		double b=scanner.nextDouble();
		double max= a>b?a:b;	
		System.out.println(max);
	}
	//3.无参数有返回值
	public double  getMax3() {
		System.out.println("请输入2 个数:");
		double a=scanner.nextDouble();
		double b=scanner.nextDouble();
		return a>b?a:b;		
	}
	
	//4.有参数,无返回值]
	public void getMax4(double a,double b) {
		double max= a>b?a:b;	
		System.out.println(max);	
	}

2.73 调用类方法

1.通过对象名.方法名(实际参数)进行调用
		//对象名.方法名
		TestMethod02 th=new TestMethod02();
		//1.有参数有返回值
		double max=th.getMax(20, 66);
		System.out.println(max);
		
		System.out.println("---------------");
		//2.无参数无返回值
		th.getMax2();
		
		//3.无参数有返回值
		double max2=th.getMax3();
		System.out.println(max2);
		
		//4.有参数,无返回值]
		th.getMax4(34, 89);

2.同一个类中方法之间相互调用  通过方法名(实际参数)调用
//重点
只有在同一个类当中才可以直接通过方法名调用,有种情况继承可以在别的类中调用
那是因为子类继承了父类所有公共的方法,都等于是调用自己类中的方法;

3.方法自己调用自己，递归调用，必须杜绝死循环情况。
public class TestMethod03 {
	/**
	 * 递归
	 * @param n
	 * @return
	 * 阶乘 计算n的阶乘 5!=5*4*3*2*1
	 */
	public static int cal(int n) {//5
		if (n==1) {
			return 1;
		}
		return n*cal(n-1);//5*4*3*2*1
	}
}

4.用static修饰的方法称为静态方法，直接使用 类名.静态方法名(实际参数)调用
public class Test {
	public static void main(String[] args) {
		/*System.out.println("递归调用");
		TestMethod03 th=new TestMethod03();
		int cal=th.cal(5);
		System.out.println("5的阶乘:"+cal);
		
		int cal2=th.cal(10);
		System.out.println("10的阶乘:"+cal2);*/
        //这里因为方法改成了static修饰,用对象.方法名(参数)所以会报错

		// 类名.静态方法名
		int cal=TestMethod03.cal(5);
		System.out.println("5的阶乘:"+cal);
	}

}

2.8 关于return

1.一个方法中的return最多只能执行一次，return意味这个方法的执行已经终止;
2.这个方法的后续代码将不会执行;
3.通过return语句返回对应类型的结果数据，非void方法必须通过return返回结果;
4.在void方法中也可以使用不跟着数据的return，表示直接跳出方法执行;
5.void方法中的return是可选的，方法中的代码执行完毕后会自然结束

2.9 自定义方法的语法

访问修饰符 (修饰符) 返回值类型  方法名(参数列表){
   // 方法体
  //  return  值;
}

1.访问修饰符：public  protected 缺省 private;
2.返回值类型：使用 return 关键字返回数据，每一个方法只能有一个返回值，返回值类型根据实际情况决定的，取决于返回的值的数据类型。
如果一个方法没有返回值，则使用void关键字进行定义;
3.参数列表：某一个方法执行的时候需要一些前提条件，此时可以将这些条件理解成参数，从外部传递进来。参数列表个数0-N个;
方法名(数据类型 形参名, 数据类型 形参名){....}

2.91 定义方法需思考的三点

1.方法是否有返回的结果，如果有，返回什么类型的结果？
2.明确方法是否需要参数，如果需要，需要几个什么类型的参数？
3.方法如何才能正确得到想要的结果？

2.10 方法体中的局部变量–>变量的作用域

定义在方法体中的局部变量和类的成员变量之间存在一些差异：
    1.成员变量：在类中定义，在当前对象的内部是共享的;
  	2.局部变量：在方法中定义，仅在本方法中有效;

比较	成员变量	局部变量
定义位置	直接在类中定义	定义在方法中
声明赋值	可以在声明时赋初始值；若不赋值，会有默认初始值，基本数据类型的值为0，引用类型的值为null	需要显式初始化后才能使用
作用域	在整个类内部都是可见的，所有成员方法都可以使用它，如果访问权限允许，还可以在类外部使用	仅限于定义它的方法，在该方法外无法访问它
注意	（1）在同一个方法中，不允许有同名的局部变量。在不同的方法中，可以有同名的局部变量 （2）局部变量可以和成员变量同名，并且在使用时，局部变量具有更高的优先级

public class Test_var {
	//属性:成员变量
	//类成员,整数,没有赋值,默认值是0
	//这个属性  在当前对象内部是共享的
    int  n;
    public void t1() {
		System.out.println("n:"+n);//0
		n++;
		System.out.println("n:"+n);//n=1
		
	//局部变量：在方法中定义，仅在本方法中有效
		int i=8;
		System.out.println("i:"+i);
	}//这个方法结束后,i已经被释放了,把它销毁
    
    public void t2() {
		n++;
		System.out.println("n:"+n);// 2 在对象内部共享
	//	System.out.println(i);//报错,i是局部变量，仅在本方法中有效
	}
    
    public static void main(String[] args) {
    	Test_var tv=new Test_var();
    	tv.t1();
    	tv.t2();
    	
    	Test_var tv2=new Test_var();
    	tv2.t1();
    	tv2.t2();
	}
}

public class Test_var2 {
	int x=10;
	public void t1() {
		System.out.println(++x);//11
	}
	public void t2() {
		System.out.println(x++);//先直接输出11,然后再加1  
		System.out.println(x);//12
	}
	public void t3() {
		x++;
		System.out.println(x);
	}
	public void t4() {
		System.out.println(x);
	}
	public void t5() {
		int x=20;
		System.out.println(x);
	}

	public static void main(String[] args) {
		Test_var2 tv=new Test_var2();
		//tv.t1();//单独调用11
		//tv.t2();//单独调用10
		
		tv.t3();//11
		tv.t4();//11
		tv.t5();//20
		System.out.println("----------------------");
		Test_var2 tv2=new Test_var2();
		//tv2.t1();//单独调用11
		//tv2.t2();//单独调用10
		
		tv2.t3();//11
		tv2.t4();//11
		tv2.t5();//20
		
		//类的不同对象操作普通变量不会相互影响
	}

}

2.11 参数传递:形参和实参

1. [形参]就是一个普通的临时变量，位置特殊只是为了跳出方法体的作用域以便能够获取实参值;
2. 方法体中的代码操作的是形参变量，和实参无关，只不过由于需要借助于实参的数据值，因此在执行方法第一条语句之前，隐式按照参数的位置关系利用实参对相应位置的实参进行了[赋值]操作;

2.12 可变参数与注意事项

有过C语言学习经历的同学可能对其中的标准输出函数 printf()非常熟悉，这个函数有个特点，提供格式字符串后，根据格式字符串中的占位符，后面可以根据占位符的个数提供不同的数据变量以供输出，这种函数的参数称为：可变参数;
Java1.5增加了可变参数特性，适用于参数个数不确定，类型确定的情况;

2.121 Java中可变参数的特点：

1. Java把可变参数[当做数组处理];
2. 可变参数必须位于[最后一项]。当可变参数个数多余一个时，必将有一个不是最后一项，所以[只支持有一个可变参数]。因为参数个数不定，所以当其后边还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项;
3. 可变参数用...代替标识， ...位于变量类型和变量名之间，前后有无空格都可以;
4. 用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数;