选择控制语句(switch)
格式:
switch(表达式为真){
case 真值1:
语句1;
break;
case 真值2:
语句1;
break;
.
.
.
default :
语句n;
break;
}
注意事项:
1,case后的值为一个常量;
2,一定要注意case中的break不要省略,否则会造成case穿透.
3,放在switch语句最后的default中的break可以省略,但不建议省略,但若default放在其他位置,则不能省略break.
4,关于switch语句的结束条件
a)要么遇见break结束
b)程序默认执行到末尾
执行流程*
switch接收结果,
1)接收的结果和case后面的值1进行对比,成立,执行语句1 ,break 结束语句;
2)值1和switch接收的结果不匹配,和值2进行比较,成立,执行语句2, break,结束语句;
3)…
如果上面case都不匹配,执行default语句,语句n,break ,结束.
// 需求:
/* 键盘录入一个值,判断星期
1,星期一
2,星期二
3,星期三,
4,星期四
5,星期五
6,星期六
7,星期日
*/
import java.util.Scanner;
public class SwicthDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请输入一个星期(1-7的数据): ") ;
int week = sc.nextInt() ;
switch (week){
case 1:
System.out.println("星期一") ;
break ;
case 2:
System.out.println("星期二") ;
break ;
case 3:
System.out.println("星期三") ;
break ;
case 4:
System.out.println("星期四") ;
break ;
case 5:
System.out.println("星期五") ;
break ;
case 6:
System.out.println("星期六") ;
break ;
case 7:
System.out.println("星期日") ;
break ;
default :
System.out.println("非法数据") ;
break ;
}
}
}
循环语句
for结构
格式:
for(初始化语句;条件表达式;控制体语句或者步长语句){
循环体语句;
}
执行流程:
1) 初始化语句:给变量赋值 (只执行一次)
2)然后执行条件表达式,看其是否成立,如果成立,执行的是循环体语句------>再次回到控制体语句或者步长语句--->变量自增或者自减
3)再次执行条件表达式,是否成立,成立,继续循环体语句---->再次回到控制体语句或者步长语句---->变量自增或者自减....
4)一直执行到条件表达式不成立,for循环结束;
水仙花数
三位数,各个位上的数的立方和等于这个三位数本身)
//需求:输出水仙花数(for循环)
public class forTest {
public static void main(String[] args) {
System.out.println("水仙花数是:") ;
// 1)三位数,明确了范围 100-999---使用for循环 x
for (int x = 100; x < 1000; x++) {
//x:100-999的数据
//确定每各位的数据本身的值:
// 定义三个变量,分别代表个位,十位,百位数据本身
int ge = x %10 ; //x=153
int shi = x /10 %10 ;
int bai = x /10 /10 % 10;
//如果当前x == (ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai),满足条件,直接输出x
if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
System.out.println(x) ;
}
}
}
}
循环求和思想:
需求:
* 1)在控制台输出1-10的相加之和
class Test{
public static void main(String[] args){
int num=0;//用来存入数据之和
for(int i=1;i>=100;i++){
num=num+i;//将相加后的值存入num中
}
System.out.println(num);
}
}
while结构
格式
while(判断表达式){
循环体语句;
控制体语句;
}
执行流程
首先,先初始化语句,对变量赋值;
执行条件表达式,是否成立;成立,则执行循环体语句,依次控制体语句进行变量控制 --->再次判断条件表达式是否成立,成立,执行循环体语句--->控制体语句进行变量控制
当条件表达式不成立,while循环结束;
注意事项:控制体语句不要忘了,否则死循环;
水仙花数
//需求:输出水仙花数(while循环)
public class while__test {
public static void main(String[] args) {
int b=100;
int count=0;
while(b<=999){
int ge=b%10;
int shi=b/10%10;
int bai=b/10/10%10;
if(b==(ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai)){
count++;
System.out.println("第"+count+"个水仙花数是:"+b);
}
b++;
}
System.out.println("共有"+count+"个水仙花数");
}
}
do…while结构
格式
do(){
循环体语句;
控制体语句;
}while(判断条件语句);
执行流程
1,先执行循环体语句和结构体语句,在执行判断条件语句,满足则继续执行循环体语句和控制体语句,不满足则退出循环.
**注**
无论判断条件语句是否满足,循环体语句和控制体语句总要执行一次
循环语句的嵌套
//需求:在控制台输出九九乘法表
public class test{
public static void main(String[] args){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(i+"x"+j+"="i*j+"\t");
}
System.out.println();
}
}
}
死循环
也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}。
在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。
例1:
while(true){
y++;
}
例2:
for(;;){
循环体语句;
}
需求:通过while死循环,不断的键盘录入的数据,产生一个随机数, 进行对比
public class Test_8_2_1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int number= (int)( Math.random()*100+1);
while(true){
System.out.println("请输入你猜的数字");
int m= sc.nextInt();
if(m>100||m<0){
System.out.println("您输入的数字不对,应该在1~100之间");
}else if(m>number){
System.out.println("对不起,你猜的大了");
}else if(m<number){
System.out.println("对不起,你猜的小了");
}else {
System.out.println("恭喜你,猜对了");
break;
}
}
}
}
三种循环语句的区别
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环
注意事项：
> 写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环。
跳出语句
break
使用场景：
终止switch或者循环
在选择结构switch语句中
在循环语句中,离开使用场景的存在是没有意义的
作用：
跳出单层循环
跳出多层循环
带标签的跳出
continue
使用场景
结束本次循环，继续下一次的循环
return
Return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方法。
方法
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当我
们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
(方法就是完成特定功能的代码块)
格式
修饰符 返回值类型 方法名 （参数列表）｛
代码（方法体）…
return ;
}
定义格式解释：
修饰符：目前固定写法 public static
返回值类型 用于限定返回值的数据类型
方法名 一个名称，为了方便我们调用方法
参数类型 限定调用方法时传入参数的数据类型
参数名 是一个变量，接收调用方法时传入的参数
方法体 完成功能的代码
return 结束方法以及返回方法指定类型的值
返回值 程序被return带回的结果，返回给调用者
注意事项
方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要有return带回一个值
//有明确返回值类型的
/*需求:
键盘录入两个数据,比较两个数据是否相等,需要定义方法来实现,并在主方法中测试
*/
package practice;
import java.util.Scanner;
public class HomeWork_8_2_5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数据");
int num1 = sc.nextInt();
System.out.println("请输入第二个数据");
int num2 = sc.nextInt();
boolean result = same(num1, num2);
System.out.println("result:" + result);
}
public static boolean same(int a,int b){
boolean result;
if(a==b){
result=true;
}else {
result=false;
}
return result;
}
}
//无明确返回值类型的方法
//需求:键盘录入两个数据,比较两个数据是否相等,需要定义方法来实现,并在主方法中测试
import java.util.Scanner;
public class HomeWork_8_2_5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数据");
int num1 = sc.nextInt();
System.out.println("请输入第二个数据");
int num2 = sc.nextInt();
same(num1, num2);
}
public static boolean same(int a,int b){
boolean result;
if(a==b){
System.out.println("true")
}else {
System.out.println("false")
}
}
}
方法重载
定义
为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关.
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
参数列表不同:参数个数不同,参数类型不同,参数类型的顺序不同.
特点:
返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
断点调试程序
断点调试程序:
在方法中的有效代码第一行打断点,在行号上直接单击即可
使用debug启动Java应用程序
右键—选择 debug run xxx类名.main :debug启动这个类的main方法.
数组
存储同种类型元素的容器.
格式分为静态初始化和动态初始化.
动态初始化
自己定义数组的长度,数组的元素有系统(jvm)默认分配
格式:
数据类型[] 数组名称 = new 数据类型[数组长度] ; 推荐第一种
数据类型 数组名称[] = new 数据类型[数组长度] ;
注
所有的数组有一个特点:数组名称[角标或者索引值]:访问数组的元素 ,角标值/索引值从0开始计算
静态初始化
直接我们自己给定的了元素内容,数组的长度由系统默认分配
格式
原生的格式写法:
* 数据类型[] 数组对象名 = new 数据类型[]{元素1,元素2,元素3.....} ;
* 数据类型 数组对象名[] = new 数据类型[]{元素1,元素2,元素3.....} ;
静态初始化的简写格式
* 数据类型[] 数组对象名 = {元素1,元素2,元素3.....} ; 推荐的写法
* 数据类型 数组对象名[] = {元素1,元素2,元素3.....} ;
在数组中有一个特有的属性:length 数组名称
.length:获取数组长度
数组中的最大索引值: 数组名称.length-
创建一个对象的内存图解
//例:需求编写方法，求数组元素的平均值
/*要求
1)定义一个方法，求数组的平均值
2)在主方法中定义对象，并初始化一个float类型的数组(直接在main方法中静态初始化一些值)，调用方法求数组元素的平均值，并将平 均值打印输出
*/
package practice;
public class HomeWork_8_3_7 {
public static void main(String[] args) {
float[] a={1,2,3,4,5,6,7,8,9};
avg(a);
}
public static void avg(float[] a){
float add=0;
for(int i=0;i<a.length;i++){
add=add+a[i];
}
float avg=(float)add/a.length;
System.out.println("该数组元素平均值为:"+avg);
}
}
注
无论是静态初始化还是动态初始化,在使用时只能遵照一种格式,切勿动静结合.
数组的遍历
//需求:定义一个方法:遍历数组int[] arr={51,54,23,14,25,69,45}
class Test{
public static void main(String[] args){
int[] arr={51,54,23,14,25,69,45};
bianli(arr);
public static void bianli(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}
}
}
}
面试题
int[] array = new int[3] ; 这句话完了哪些事情? ----内存干了什么事情
1)需要在栈内存中开辟 空间, int[] array这个变量
2)new int[3] ; 需要在堆内存中申请空间
3)为这个堆内存中的这些数组的元素,进行系统默认初始化,int类型的元素在
数组中默认值0
4)系统初始化完毕,为堆内存空间产生一个空间地址值,
5)将堆内存空间地址值赋值给栈内存的变量array
6)栈内存变量 array指向堆内存地址
数组的其他基本应用
数组元素查表法 :通过数组名称[索引值]确定元素
基本元素查询:查询数组中某个元素的角标值int[] arr = {87,56,13,24,17};
弊端:
每次查询元素的时候,都是从头查到尾
数组的逆序
//2022/8/4
/*
int[] arr={20,15,34,86,94,100}
定义方法使该数组变成逆序
*/
package practice;
public class array__test {
public static void main(String[] args) {
int[] arr = {20, 15, 34, 86, 94,100};
System.out.println("互换前:");
System.out.print("[");
for(int m=0;m<arr.length;m++){
if(m<arr.length-1){
System.out.print(arr[m]+",");
}else{
System.out.println(arr[m]+"]");
}
}
System.out.println("------------------------------------------------");
System.out.println("互换后:");
test(arr);
array2(arr);
}
public static void test(int[] arr) {//方法一
System.out.print("[");
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1-i];
arr[arr.length - 1-i] = temp;
}
for(int m=0;m<arr.length;m++){
if(m<arr.length-1){
System.out.print(arr[m]+",");
}else{
System.out.println(arr[m]+"]");
}
}
}
public static void array2(int[] arr){//方法二
System.out.print("[");
for(int start=0,end=arr.length-1;start<end;start++,end--){
int temp=arr[start];
arr[start]=arr[arr.length-1-start];
arr[arr.length-1-start]=temp;
}
for(int m=0;m<arr.length;m++){
if(m<arr.length-1){
System.out.print(arr[m]+",");
}else{
System.out.print(arr[m]+"]");
}
}
}
}
数组的冒泡排序
//2022/8/4
/*
int[] arr={20,15,34,86,94,100}
定义方法用冒泡排序使该数组有序
*/
package practice;
public class array__test2__maopaopaixu {
public static void main(String[] args) {
int[] arr={20,15,34,86,94};
System.out.println("排序前");
bianli(arr);
System.out.println("----------------------");
System.out.println("排序后");
paixu(arr);
bianli(arr);
}
public static void bianli(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}
}
public static void paixu(int[] arr){
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
面向对象
三大特征:
封装,继承,多态
思想特点
1)更符号生活中的思想行为习惯
2)让复杂的事情简单化
3)从执行者变成了指挥者
面向对象语言被语言被设计出来的理念
不断的去创建对象,使用对象,指挥对象做事情!
类
类,是能够描述现实世界事物一组属性和行为的集合
类和事物的关系
一一对应
/*
学生事物 ---- > 类
属性: 姓名,身高, 年龄 等等.. 类中的成员变量:在类中方法外定
义的变量
行为: 主要目的学习....
描述上面的学生事物
Java中定义类
*/
class Student{
//在代码体现出这个学生的属性 :
//成员变量:
}
//代码体现出来对某个事物的描述以及在对应的主方法中测试;
/*
1.学生事物
属性：姓名，年龄，性别，发型
行为：吃饭，抽烟，打游戏，学习Java
*/
package com.qf.test1;
public class Student {//事物类
String name;
int age;
String danger;
String hair;
public void eat(){
System.out.println("他正在吃饭");
}
public void smoke(String pinpai){
System.out.println("他喜欢抽"+pinpai+"的烟");
}
public void playGame(String game){
System.out.println("他喜欢玩"+game);
}
public void study(){
System.out.println("他正在学习Java");
}
}
package com.qf.test1;
public class studentTest {//测试类
public static void main(String[] args) {
Student s=new Student();
s.name="小明";
s.age=22;
s.danger="男";
s.hair="飞机头";
System.out.println("他叫"+s.name+",年龄:"+s.age+",性别:"+s.danger+",头发是:"+s.hair);
s.eat();
s.smoke("煊赫门");
s.playGame("GTA5");
s.study();
}
}
基本类型作为形式参数和引用类型作为形式参数的特点
基本类型作为形式参数,形式参数改变不影响实际参数;
引用类型作为形式参数,形式参数的改变直接影响实际参数;
基本类型作为形式参数和引用类型作为形式参数的特点 图解
封装
定义
*就是将显示世界事物的属性隐藏了(加入一个关键字private),
*私有的,无法直接访问的,对外数据的安全性!(外界不能访问的)
*对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())
注意事项
以后在书写的代码的时候,写一个类,描述真是存在事物的属性的时候,
需要属性(英文单词字母全部小写)全部加入private(开发中属性大多私有,除非明确告诉共有)
关键词
private
面试题
private关键字的特点?
1)被private修饰的成员变量以及成员方法只能在本类中访问
2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
3)被private修饰的成员变量/成员方法可以间接的通过公共的方法访问
/*
对学生类进行封装,并在主方法中进行测试
学生事物
属性：姓名，年龄，性别，发型
行为：吃饭，抽烟，打游戏，学习Java
*/
package practice;
public class Demo {//事物类
private String name;
private int age;
private String danger;
private String hair;
public void setName(String n){
name=n;
}
public String getName(){
return name;
}
public void setAge(int a){
age=a;
}
public int getAge(){
return age;
}
public setDanger(String d){
danger=d;
}
public String getDanger(){
return danger;
}
public void setHair(String h){
hair=h;
}
public String getHair(){
return hair;
}
public void playGame(String game){
study();
System.out.println("他喜欢玩"+game);
}
private void study(){
System.out.println("她正在学习JavaEE");
}
}
package practice;
public class DemoTest {//测试类
public static void main(String[] args) {
Demo d=new Demo();
d.setName("小伟");
d.setAge(20);
d.setDanger("男");
d.setHair("飞机头");
System.out.println("他的名字是:"+d.getName()+",年龄是:"+d.getAge()+",性别:"+d.getDanger()+"头型是:"+d.getHair());
d.playGame("GTA5");
}
}
扫一扫
4843
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
