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关键字 构造方法 面向对象特征:封装和继承