类和对象

1回顾

编程语言三部分组成：

顺序结构：从顶到下，逐步求精，每一步都会执行

分支结构：选择性的执行，条件为true执行if，条件为false执行else

循环结构：条件成立(true)的情况下重复执行某个操作

1.1循环

1.1.1 已知循环次数

​ for( ; ; )

​ 场景：输入一个整数判断是否为素数？

​ 分析： 除了1和其本身以外不能被任何数整数，例如 5 97 13 11

​ 步骤：1 定义一个boolean变量 , 用来存储判断的结果 true 是素数 false不是 默认true

​ 2 输入整数 5

​ 3 逐个遍历除了1和它本身以外的所有整数，如果能够被整除 不是素数(false)

​ 4 一旦 boolean 为false，终止循环（不是素数）

​ 5 判断如果boolean为true打印素数，false不是素数

package com.whsxt.day1.homework;

import java.util.Scanner;

/**
 * @author caojie
 *场景：输入一个整数判断是否为素数？
	分析： 除了1和其本身以外不能被任何数整数，例如  5      97       13     11
	步骤：1 定义一个boolean变量  ,  用来存储判断的结果  true 是素数 false不是  默认true
		    2  输入整数    5
		    3   逐个遍历除了1和它本身以外的所有整数，如果能够被整除 不是素数(false)
		    4   一旦 boolean 为false，终止循环（不是素数）
		    5   判断如果boolean为true打印素数，false不是素数
 */
public class Homework1 {
	public static void main(String[] args) {
		//存储结果 true表示是一个素数，false不是 默认true
		boolean flag = true;
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个大于2的整数");
		//5
		int num = input.nextInt();
        //  i的全称是index
		for(int i=2;i<num;i++){
			//逐个判断num能够被i整除
			//条件成立：能够被整除，不是素数
			if(num%i==0){
				//能够被整除，改变Boolean的值为false
				flag =false;
				//终止循环
				break;
			}
		}
		//判断boolean值
		if(flag){
			System.out.println(num+"是素数");
		}else{
			System.out.println(num+"Is  Not SuShu");
		}
	}
}

调试程序

为什么需要调试程序？

因为我们不知道程序如何运行，也不知道每一步的变量如何赋值

调试的步骤？

1 打断点（程序不会运行，而是进入阻塞状态）

​ 哪一行看不懂，就双击它

2 按住F11调试程序

3 按住F6执行下一步

​ 边调试边观察变量

4 按住F8 一直往下走，结束调试

1.1.2 未知循环次数

​ 循环之前：定义初始化变量

​ while(条件){

​ //循环体

​ // 更新循环遍历

​ }

场景：输入学员成绩输入-1结束

package com.whsxt.day1.homework;

import java.util.Scanner;

/**
 * @author caojie
 *场景：输入学员成绩输入-1结束
 *1 定义Scanner输入
 *2 使用循环来接收用户的输入
 */
public class Homework2 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		//while工作中什么时候使用？未知循环次数
		while(true){
			System.out.println("请输入成绩，输入-1结束");
			//成绩
			int score = input.nextInt();
			//条件判断：条件成立终止循环
			if(score==-1){
				break;
			}
			System.out.println("score="+score);
		}
	}
}

注意：工作中如果需要用到循环，首先考虑for循环，如果for(已知循环次数)不能解决当前问题，再考虑while(未知循环次数)循环， 工作中for循环使用的比重90%

1.2方法

概念：完成某个特定功能的一些列指令(程序)的集合

特定功能：例如判断一个数是否为素数

为什么需要使用方法？

提高代码的可读性、复用性(编写一次，反复使用)

如何定义方法？

语法：

修饰符 返回类型 方法名(参数列表){

}

例如：

public static void main(String args[]){

}

package com.whsxt.day1.homework;

import java.util.Scanner;

/**
 * @author caojie
 *场景：输入一个整数判断是否为素数？
	分析： 除了1和其本身以外不能被任何数整数，例如  5      97       13     11
	步骤：1 定义一个boolean变量  ,  用来存储判断的结果  true 是素数 false不是  默认true
		    2  输入整数    5
		    3   逐个遍历除了1和它本身以外的所有整数，如果能够被整除 不是素数(false)
		    4   一旦 boolean 为false，终止循环（不是素数）
		    5   判断如果boolean为true打印素数，false不是素数
 */
public class Homework1 {
	
	/**
	 * 判断某个整数是否为素数
	 * 返回结果要么true 要么false
	 * @param num 表示外界传递的数据，要判断的整数
	 * return 返回结果true是素数，false不是素数
	 * 步骤：1 定义Boolean类型变量  flag
	 * 		 2 使用循环遍历除了1和本身之外所有的整数
	 * 		 3 判断num能否被整除(除了1和本身之外所有的整数)
	 * 		 4 如果能够被整除 flag设置为false(不是素数)，终止循环
	 * 		 5 返回计算的结果
	 * */
	 public static boolean judgeSuShu(int num){
		 //flag是一个判断素数的标志变量true表示是素数，false不是
		 //默认是素数
		 boolean flag = true;
		 for(int i=2;i<num;i++){
			 //条件成立：num能够被i整除,不是素数,终止循环
			 if(num%i==0){
				 flag = false;
				 break;
			 }
		 }
		 //1 方法执行结束，离开judgeSuShu(int num)方法
		 //2 将结果返回给调用者
		 return flag;
	 }
	
	/**
	 * 调用judgeSuShu()方法步骤
	 * 1 定义Scanner
	 * 2 输入整数 num
	 * 3 将输入的整数作为参数，调用judgeSuShu(num)
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个大于2的整数");
		int num = input.nextInt();
        //在main()方法中调用judgeSuShu(num)方法
		boolean result = judgeSuShu(num);
		if(result){
			System.out.println(num+"是素数");
		}else{
			System.out.println(num+"Not  素数");
		}
	}
}

1.3数组

概念：存储相同数据类型的一组数据的集合

1.3.1定义数组

//数组定义语法：
//数据类型  变量名  数组运算符 ；
int   arrs  [] ;
int   []  arrs ;
//数组定义并且分配内存空间语法
//数据类型  变量名  数组运算符 = new 数据类型[数组大小];
int arrs [] = new int[10];
int []  arrs = new int[10];
// 定义数组直接分配值
// 数据类型  变量名 数组运算符 ={数组元素1,数组元素2,,,,,};
int arrs [] = {6,8,4,3,7};
// 定义数组直接分配值
int arrs[] = new int[] {6,8,7,9,4,3,71};

1.3.2 访问数组元素

//一维数组是一个线性结构
int arrs[] = {8,6,7,3,2,5};
//如何访问数组的第三个元素，可以通过数组下标来访问,数组下标从0开始
//为什么数组下标从0开始？而不是从1开始
//8    6    71   3   2   51
//0    1    2    3   4   5
//8距离自己的偏移量(偏移位置)是0，所以8的下标为0
//6距离8的偏移量是1(偏移位置)，所以6的下标为1
//51距离8的偏移量是5(偏移位置)，所以51的下标是5

1.3.3数组在内存中的存储方式

/**
 * @author caojie 数组在内存中的存储方式
 */
public class TestArray1 {
	public static void main(String[] args) {
        //基本数据类型：在栈内存中存储实实在在的值
		int age = 18;
		int arr[];
        //引用数据类型：在栈内存中存储的是地址
		arr = new int[5];
		arr[3] = age;
		System.out.println(arr[3]);
	}
}

1.3.4二维数组

数组中的数组(一个数组里面嵌套另一个数组)，是一个平面结构

int arrs[][] ={{10,20,30},{50,70,80},{40,60,90}};
int arrs[][];
int [][];
//以new的行为数组分配空间
int [] arrs[] =new int[3][3];
//为二维数组赋值
arrs[0][0] =20;
arrs[1][2] =30;
//如何遍历二维数组

遍历二维数组

/**
 * @author caojie
 *遍历二维数组
 */
public class TestArray2 {
	public static void main(String[] args) {
		//以new的行为数组分配空间
		int [] arrs[] =new int[3][3];
		//为二维数组赋值
		arrs[0][0] =20;
		arrs[1][2] =30;
		//如何遍历二维数组
		//遍历二维数组中的每一个小数组
		for(int arr[] : arrs){
			//遍历每个小数组中的元素
			for(int num: arr){
				System.out.print(num+"\t");
			}
			System.out.println();
		}
	}
}

使用下标来遍历

package com.whsxt.day1.homework;

/**
 * @author caojie
 *使用数组下标遍历
 *如果需要对数组元素做改动，使用下标遍历
 *如果只读取数组元素，使用forEach循环
 */
public class TestArray3 {
	public static void main(String[] args) {
		int [] arrs[] ={{1,4,7},{2,5,8},{3,6,9}};
		//定义变量存储数组，长度只获取一次，节约内存
		int length = arrs.length;
		//遍历外层的大数组
		for(int i=0;i<length;i++){
			//当i=0，arrs[i]表示取大数组中的第一个小数组{1,4,7}
			for(int j=0;j<arrs[i].length;j++){
				//条件成立，重新设置数组的值
				if(i==1 && j==1){
					arrs[i][j]=10101;
				}
				//打印元素
				System.out.print(arrs[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

小结：只遍历数组元素使用forEach循环(读)

​ 改变数组元素使用for循环+下标(写)

思考题：基本类型数组和引用类型数组区别

​ int [] ={1,2,3};

​ String [] ={“水浒传”,“三国演义”,“红楼梦”,“西游记”};

​ 基本类型存储实实在在的值，在堆内存中只会指向一次

​ 引用累心存储对象的地址，在堆内存中指向两次

2类和对象

注重知识，不要死学知识

IT工作者文房四宝 电脑 笔 记事本 水杯

2.1面向过程编程

​ 面对一个问题，考虑分步骤的方式去解决，不去考虑对象的存在。

2.2面向对象编程

​ 面对一个问题，考虑解决该问题定义多少个对象，再考虑每个对象有哪些特征和行为，最后考虑对象之间的关系(对象之间如何协作)

​ 场景1：判断某个年份是否为闰年。

​ 对象：Leap(闰年)

​ 特征： int years;

​ 行为： Boolean judgeLeap()； 判断闰年的逻辑

​ 场景2：老曹开车去重庆(对象使用名词定义)

​ 对象： 老曹 车 重庆(导航、地图)

​ 每个对象有哪些特征？和行为？

​ 老曹的特征：身高、年龄、姓名…

​ 老曹的行为：驾驶

​ 车的特征：颜色、品牌、价格…

​ 车的行为：start()开启 stop()停车 speed() 驾驶

​ 导航的特征： 宽度、高度、颜色、品牌

​ 导航的行为：导航

​ 小结：特征是静态的（名词命名）、行为是动态的(动词命名)、对象静态的（名词命名）

​ 老曹和车之间是has a 的关系，老曹有一辆车

​ 车和导航之间是has a 的关系， 车有导航

[外链图片转存失败(img-WAGSVbWt-1563420162259)(面向对象.png)]

2.3什是类

class当做一个类(国内)

type当做一个类(海外) type是类型的意思

概念：是一个抽象的概念，表示一个类型，一个类型可以有一个或者多个对象(Person是一个类型，张三、

李四等等都是人类的对象)，所以我们把具有相同属性和行为的一组对象封装成一个类(class or type)

2.4什么是对象

​ 对象 Object

​ 类的对象

​ 概念：一组客观存在的事物。

​ 特征：真实的

​ 类是一个抽象的概念，对象是客观存在的。

​ 类和对象之间的关系？

​ 类可以理解为：冰淇淋机器

​ 对象理解为：通过冰淇淋机器创建的一个具体的、真实存在的冰淇淋

​ 通过类(class)来创建(产生)对象，例如：通过冰淇淋机器可以产生冰淇淋。

2.5对象的特征和行为

[外链图片转存失败(img-lIzchSN6-1563420162260)(英雄联盟.png)]

上述的图，可以定义一个英雄类型(Type), 通过类型我们可以产生若干个对象.例如：提莫、亚索…

​ 每个对象都有自己的特征：例如： 提莫对象有 hp（血量） def（防御） str(攻击力)

​ 每个对象都有自己的行为： attack( 进攻) 、desc()自我介绍 、种蘑菇、换技能

2.6如何定义类

[外链图片转存失败(img-qJmW0FqN-1563420162261)(Hero类型.png)]

java定义类的语法：

//定义类遵循的规范：只能使用大写字母开始
public class <类名称>{
    //特征
    //行为
}
//注意：特征行为可有可无，但是类名称必须有，{}必须有   class关键字必须有

Hero代码如下：

package com.whsxt.day1.oop;

/**
 * @author caojie
 * 定义一个Hero类
 * 有如下特征：名称、血量、攻击力、防御力
 */
public class Hero {
	
	String name;
	
	/**
	 * 英雄的血量
	 */
	int hp;
	
	/**
	 * 攻击力
	 */
	int str;
	
	/**
	 * 防御力
	 */
	int def;
	
	/**
	 * 英雄具有攻击对方的行为
	 */
	public void attack(){
		System.out.println(name+"完成了一次攻击");
	}

	/**
	 * 某个英雄对象的描述(介绍)
	 */
	public void desc(){
		System.out.println("名称："+
					name+" 血量："+
					hp+" 攻击力："+
					str+" 防御力："+def);
	}
}

2.7如何创建对象

如何创建类型(Type or Class)的对象?

Java有三种创建对象的方式，第一种使用new关键字创建对象

例如：  Scanner input = new Scanner(System.in);
		//调用行为
	   int num = input.nextInt();

如何创建Hero类型的对象

//创建了一个Hero类型的对象，对象名称叫做TiMo
// Hero tiMo = new Hero();
//创建了一个Hero类型的对象，对象名称叫做yaSo
// Hero yaSo = new Hero();

[外链图片转存失败(img-dq3164B9-1563420162262)(对象内存图.png)]

使用代码创建Hero类型的对象

package com.whsxt.day1.oop;

/**
 * @author caojie
 *Game类型，游戏里面可以创建若干个Hero类型的对象
 */
public class Game {
	public static void main(String[] args) {
		//创建两个对象
		Hero tiMo = new Hero();
		//调用方法之前为属性赋值
		// .  dot  .理解为“的” 为tiMo对象的name属性赋值
		//tiMo对象的名称为"提莫"
		//name是tiMo对象的特征(属性)
		//属性初始化(为每个属性赋初始值)
		tiMo.name="提莫";
		//血量
		tiMo.hp=550;
		//防御力
		tiMo.def=53;
		//攻击力
		tiMo.str=61;
		//调用攻击的行为
		//注意：调用行为(方法)之前，属性已经妥善的赋值(初始化)
		tiMo.attack();
		//调用介绍信息的行为
		tiMo.desc();
		//创建yaSo对象
		Hero yaSo = new Hero();
		//为对象的属性初始化（赋初始值）
		yaSo.name="亚索";
		yaSo.hp=610;
		yaSo.str=570;
		yaSo.def=560;
		//调用方法
		yaSo.attack();
		yaSo.desc();
	}
}

作业：1定义装备类

​ 定义如下属性： 攻击力、防御力、生命

​ 定义如下方法：n秒无敌、描述(增加攻击力XXX)

​ 创建两件装备对象：沙漏、复活甲

​ 设置属性，然后调用方法

package com.whsxt.day1.oop;

/**
 * @author caojie
 *装备类型
 *有如下特征(属性)：装备名称、血量、攻击力、防御力......
 *有如下行为(方法)：n秒无敌 ，描述装备
 */
public class Equipment {

	/**
	 * Alt+Shift+J
	 * 装备名称
	 */
	String name;
	
	/**
	 * 装备的血量
	 */
	int hp;
	
	/**
	 * 攻击力
	 */
	int str;
	
	/**
	 * 防御力
	 */
	int def;
	
	/**
	 * N秒无敌的行为
	 * @param second  外界传入到方法的参数 此时表示秒
	 */
	public void wuDi(double second){
		System.out.println(second+"秒无敌装备");
	}
	
	public void desc(){
		System.out.println("装备名称："+name
				+" 装备血量："+hp
				+" 装备攻击能力："+str
				+" 装备的防御力："+def);
	}
}

Game 类

package com.whsxt.day1.oop;

public class Game2 {
	public static void main(String[] args) {
		//创建对象：沙漏
		Equipment shaLou = new Equipment();
		//为对象的属性赋值 
		//shaLou对象的名称是“沙漏”
		shaLou.name = "沙漏";
		shaLou.hp= 600;
		shaLou.str = 90;
		shaLou.def = 85;
		//调用方法
		shaLou.wuDi(1.5);
		shaLou.desc();
		//创建对象：复活甲
		Equipment fuHuoJia = new Equipment();
		fuHuoJia.name="复活甲";
		fuHuoJia.hp= 750;
		fuHuoJia.str=80;
		fuHuoJia.def=78;
		//调用方法
		fuHuoJia.wuDi(1);
		fuHuoJia.desc();
	}
}

​ 2定义汽车类

​ 该类有如下属性：品牌、价格、颜色

​ 该类有如下方法：开车、刹车、转弯

​ 在main方法中创建3个汽车对象，并调用汽车的属性和方法

package com.whsxt.day1.oop;

/**
 * @author caojie
 *Car有品牌、价格、颜色等属性
 *Car有启动、刹车、转弯等行为(方法)
 */
public class Car {

	/**
	 * 车的品牌
	 */
	String brand;
	
	/**
	 * 车的价格
	 */
	double price;
	
	/**
	 * 车的颜色
	 */
	String color;
	
	/**
	 * 车有启动行为
	 */
	public void start(){
		System.out.println(brand+"品牌的车启动，"
				+ "价格是"+price+
				" 颜色是："+color);
	}
	
	/**
	 * 车有刹车行为
	 */
	public void stop(){
		System.out.println(brand+"正在刹车");
	}
	
	/**
	 * 车的转弯行为
	 */
	public void turn(){
		System.out.println(brand+"正在急转弯");
	}
}

测试类：

package com.whsxt.day1.oop;

/**
 * @author caojie
 *一场赛车游戏有多台车
 */
public class CarGame {
	public static void main(String[] args) {
		Car yellowCar = new Car();
		//为yellowCar对象赋值
		yellowCar.brand="奥迪A8";
		yellowCar.price= 800000;
		yellowCar.color="YellowCar";
		//调用方法
		yellowCar.start();
		yellowCar.turn();
		yellowCar.stop();
		
		Car blueCar = new Car();
		
		Car blackCar = new Car();
	}
}

2.8 成员变量和局部变量

定义在方法外面的变量叫做成员变量

成员变量可以在多个方法中使用

定义在方法里面的变量叫做局部变量

局部变量只能在一个方法中使用

注意：1局部变量只能在方法定义出使用，不能跨方法使用

​ 2 当局部变量和成员变量名称相同，优先使用局部变量(就近原则，因为局部变量里方法体近)

​ 3 局部变量必须先附初始值(初始化)才能使用，否则编译报错

​ 4成员变量不赋初始值也可以使用，因为程序运行时JVM会为每个成员变量分配一个默认值

package com.whsxt.day1.oop;

public class Student {
	
	/**
	 * 成员变量(成员属性)
	 */
	String stuName;
	
	/**
	 * 学生有学习的方法(行为)
	 */
	public void study(){
		//当局部变量和成员变量名称相同，优先使用局部变量
		//局部变量必须先附初始值(初始化)才能使用，否则编译报错
		//成员变量不赋初始值也可以使用，因为程序运行时JVM会为每个成员变量分配一个默认值
		//String stuName;
		//Tom正在学习
		//System.out.println(stuName+"正在学习");
		System.out.println(stuName+"正在学习");
	}
	
	public void eat(){
		//局部变量只能在方法定义出使用，不能跨方法使用
		//System.out.println(age);
		System.out.println(stuName+"正在吃饭");
	}
}

测试类

package com.whsxt.day1.oop;

/**
 * @author caojie
 *学校有学生
 */
public class School {
	public static void main(String[] args) {
		Student tom = new Student();
		tom.stuName="Tom123";
		tom.study();
	}
}

总结：

​ 重点掌握：

​ 如何定义类？

​ 如何定义属性(特征)？

​ 如何定义方法？

​ 如何创建对象？

​ 如何为对象的属性赋值？

​ 如何调用方法？

​ 理解：什么是类(Type or Class)

​ 什么是对象

​ 了解：面向过程编程的概念

​ 了解面向对象编程的概念

​ 作业：定义Student类型

​ 定义Worker类型

​ 定义Framer类型

​ 特征和行为自己设计

​ 预习：this关键字 构造方法 面向对象特征：封装和继承

变量
//局部变量必须先附初始值(初始化)才能使用，否则编译报错
//成员变量不赋初始值也可以使用，因为程序运行时JVM会为每个成员变量分配一个默认值
//String stuName;
//Tom正在学习
//System.out.println(stuName+“正在学习”);
System.out.println(stuName+“正在学习”);
}

public void eat(){
	//局部变量只能在方法定义出使用，不能跨方法使用
	//System.out.println(age);
	System.out.println(stuName+"正在吃饭");
}

}

测试类

```java
package com.whsxt.day1.oop;

/**
 * @author caojie
 *学校有学生
 */
public class School {
	public static void main(String[] args) {
		Student tom = new Student();
		tom.stuName="Tom123";
		tom.study();
	}
}

总结：

​ 重点掌握：

​ 如何定义类？

​ 如何定义属性(特征)？

​ 如何定义方法？

​ 如何创建对象？

​ 如何为对象的属性赋值？

​ 如何调用方法？

​ 理解：什么是类(Type or Class)

​ 什么是对象

​ 了解：面向过程编程的概念

​ 了解面向对象编程的概念

​ 作业：定义Student类型

​ 定义Worker类型

​ 定义Framer类型

​ 特征和行为自己设计

​ 预习：this关键字 构造方法 面向对象特征：封装和继承

​