流程控制语句
switch
格式:
switch(表达式) {
case 常量1:
语句体1;
break;
case 常量2:
语句体2;
break;
......
case 常量n:
语句体n;
break;
default:
语句体n+1;
}
判断月份
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份:");
int a = sc.nextInt();
switch (a) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("请输入合法数据!");
break;
}
}
}
switch语句 执行流程:先匹配case里的内容 匹配不到 直接执行default
要注意加break,防止case穿透.
1.循环结构语句
for循环
格式:
for(初始化语句; 逻辑表达式; 步进表达式) {
循环语句体;
}
执行流程:
- 执行初始化语句
- 执行逻辑表达式,如果返回false,直接结束for循环如果返回true,执行循环语句体循环语句体
- 执行完毕后,执行步进表达式
- 重复步骤(2)
示例:
水仙花数
public class shuixian_number {
public static void main(String[] args) {
for(int i=100;i<1000;i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
System.out.println(i);
}
}
}
}
nn乘法表
import java.util.Scanner;
public class nnTable {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入n:");
int n = sc.nextInt();
for(int i = 1;i<=n;i++){
for (int j = 1;j<=i;j++) {
System.out.print(j + "*" + i+ "=" + (i * j) + "\t" );
}
System.out.println();
}
}
}
while循环
格式:
while(逻辑表达式) {
循环语句体;
步进表达式;
}
执行流程:
- 执行初始化变量
- 执行逻辑表达式,如果为false,直接结束while循环,如果为true,执行循环语句体
- 执行步进表达式
- 回到步骤2.
示例:
1-100 的奇数和
public class sum {
public static void main(String[] args) {
int i = 1;
int sum = 0;
while(i<=100){
if (i % 2==0) {
sum=sum+i;
}
i++;
}
System.out.println(sum);
}
}
do - while
格式:
初始化变量;
do {
循环语句体;
步进表达式;
} while(逻辑表达式);
执行流程:
- 执行初始化变量
- 执行循环语句体
- 执行步进表达式
- 执行逻辑表达式,如果返回false,整个循环结束
- 如果返回true,回到步骤2.
开发中常用for循环,不满足也需要执行一次的时候用do - while
死循环: 一直执行下去
while(true){ for(;;){
循环语句体 循环语句体
} }
for循环和while循环可能一次都不会执行,但是do-while语句无论满不满足条件都需要执行一次.
跳转语句
break: 结束所在层次的循环
continue: 结束所在循环,继续外层循环.
return :结束方法
2.方法
将一段具有特定功能的代码,使用大括号包围起来,起一个名字,加上一些权限和修饰,就是方法。以后使用这一段代码,只需要书写方法的名字调用.
public static void getSum(int i){
}
格式:
权限修饰符 静态 返回值类型 方法名称(参数列表) {
方法体;
return语句;
}
无返回值类型的返回值类型为void return语句省略.
方法的调用:
直接调用:直接书写方法名称调用方法,让方法执行
输出调用:调用有返回值的方法,将具体返回的结果进行输出
赋值调用:调用有返回值的方法,将返回结果赋值给对应类型的变量
return 这个关键字用来结束方法
结合有具体返回值类型的方法的使用 返回方法指定类型的值,
无返回值时,省略return.
求三个数中最大的数.
import java.util.Scanner;
public class 3Number_max {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入三个数:");
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int max= max_number(a,b,c);
System.out.println(max);
}
public static int max_number(int a,int b, int c){
int temp = (a>b)?a:b ;
int result= (temp>c)?temp:c;
return result;
}
}
方法的重载: overland
定义:
在同一个类中,方法名相同,参数列表不同,与返回值类型无关
相同功能,相同逻辑,但是参数列表不同的方法,使用相同的方法名,表示这一类方法,在传入参数的时候,通过不同的参数列表匹配不同的参数,自动匹配相对应的方法.
为了功能拓展性
方法的重载
//方法重载 方法名完全相同(大小写) 参数列表不同
//为了功能拓展性
public class overload_test {
public static void main(String[] args) {
/* Scanner sc=new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();*/
System.out.println( getSum(10,20));
System.out.println( getSum(10,20,30));
System.out.println( getSum(10,20,30,40));
}
public static int getSum(int a,int b){
int result = a+b;
return result;
}
public static int getSum(int a,int b,int c) {
int result = a + b + c;
return result;
}
public static int getSum(int a,int b,int c,int d) {
int result = a + b + c + d;
return result;
}
}
方法的注意事项:
1.方法不能嵌套.
2.方法的先后没有区别,方法执行的先后顺序只会取决于调用的顺序.
3.方法可以嵌套调用,方法可以自己调自己.
4.方法如果有具体的返回内容,就写成return,结果返回给调用者,返回值是什么类型,就写对应的类型.
5.无返回值的方法可以省略return
1.数组
定义:
就是用于存储相同数据类型的数据的容器
格式:
动态格式:
数据类型[] 数组名称 = new 数据类型[数组容量];
静态格式:
数据类型[] 数组名称 = { 数据 }
注意:
数组一旦创建,大小不可更改
一种数据类型的数组,只能存储一种数据类型的数据
数组的内存理解:
方法区:存储字节码对象,存储静态相关的内容和常量.
栈: 执行方法的区域,方法加载分配内存进栈.
堆:用于存储数组.对象等数据量较大的数据,这些数据一般为引用数据类型.
异常:
数组索引越界异常
访问的索引超出了已有索引的范围.
空指针异常
地址为空,堆内存中没有开辟空间.
数组的遍历:
一个一个经历元素,所有的元素都访问一遍
数组索引的起点: 0 终点 :数组名称.length - 1
遍历数组:
public class arr_bl {
public static void main(String[] args) {
int arr[] = {8,7,5,6,2,3};
for (int i = 0; i < arr.length-1; i++) {
}
printArray(arr);
}
public static void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length; x ++){
if(x==arr.length-1){
//取到最大索引值
System.out.println(arr[x]+"]");
}else{
//没有取到最大索引值
System.out.print(arr[x]+", ");
}
}
}
}
数组的逆序
数组的倒置
public class array_reverse {
public static void main(String[] args) {
int arr[] = {1, 2, 3, 4, 5,};
// System.out.println(arr.length);
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
array_print(arr);
}
public static void array_print(int array[]) {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i== array.length-1) {
System.out.print(array[i]+"]");
}else{
System.out.print(+array[i]+", ");
}
}
}
}
获取数组的最值.
package com.qf.Demo.HomeWork;
判断最值.
import java.util.Scanner;
public class min_number {
public static void main(String[] args) {
System.out.println("请输入五个数:");
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int arr []= {a,b,c,d,e};
int m = maxNumber(arr);
System.out.println(m);
}
private static int maxNumber(int [] arr) {
int min = arr[0];
for (int i = 0; i< arr.length-1; i++){
if(min > arr[i]){
min = arr[i];
}
}
return min;
}
}
冒泡排序法
/*
两两比较,较大的值往后边放,第一次比较完毕,最大值出现在最大索引处;
依次比较
*/
public class maopao {
public static void main(String[] args) {
System.out.println("排序后:");
int arr[]={4,5,1,3,2,15};
compare(arr);
array_print(arr);
}
private static void compare(int[] arr) {
for (int i = 0; i< arr.length-1; i++){ //控制循环次数 i < 0 ,1 ,2 ,3
for (int j = 0; j < arr.length-1-i; j++) { // <arr.length-1 防止角标越界 元素比较次数
if (arr[j]>(arr[j+1])){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1]=temp;
}
}
}
}
public static void array_print(int array[]) {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i== array.length-1) {
System.out.print(array[i]+"]");
}else{
System.out.print(+array[i]+", ");
}
}
}
}
面向对象:
类和对象:
类是对具体事物的一些抽象认识,概括的是一类事物共性的属性和行为.抽象的概念
对象是一个真实存在的事物是属性和行为的具体表现,属性的载体,行为的执行者.
对象的创建和使用
对象是一个真实存在的事物是属性和行为的具体表现,属性的载体,行为的执行者.
对象当中存放的是对应类当中的非静态(除static修饰的)所有属性和方法。
静态方法属于整个类,会随着类只分配一次内存调用,对象也可调用。
格式 :
类名 对象名 = new 类名(); Scanner sc = new Scanner(System.in);
访问:
对象名.属性名访问方法:
对象名.方法名(实参列表);修改:
对象名.属性名 = 属性值;
示例:
/* 学生事物
属性:姓名,年龄,性别,发型
行为:吃饭,抽烟,打游戏,学习Java */
class Student {
String name;
int age;
String sex; //成员变量 类中方法外
public void study( ) {
System.out.println("学习:javaEE");
}
public void game (String gameName) {
System.out.println("游戏:"+gameName); //csGo
}
}
class StudentTest{
public static void main(String[] args) {
Student s = new Student();
s.name ="王盼盼";
s.age = 23;
s.sex = "男";
System.out.println(s.name+","+s.age+","+s.sex);
s.study();
s.game("csGo");
}
}
成员变量和局部变量的区别
成员变量 :是一个变量,定义在类中,属于类的成员,这种变量就叫做成员变量
局部变量:是一个变量,定义在方法中,属于方法的成员,对于类而言,方法只是一个部分,所以是局部。
内存时间不同,生命周期不同
成员变量:属于对象,随着对象的创建而创建,随着对象的消亡而消亡
局部变量:属于方法,随着方法的进栈而创建,随着方法的出栈而消亡
基本类型作为形式参数和引用类型(数组 类 接口)
基本数据类型 :
随着方法的调用的结束而结束
形式参数的改变不会影响到 实际参数的数值.
引用数据类型:
String 字符串 引用类型 形式参数的改变不影响实际参数
引用类型作为形式参数传递:形式参数的改变直接影响实际参数的数值.
封装:
封装:隐藏事物的实现细节,对外提供公共的访问方式
封装好处:
隐藏事物的实现细节
提高了代码的复用性
提高了安全性
private关键字
private,关键字,含义:私有的;权限修饰符:
修饰成员变量
修饰成员方法
特点:被private修饰的成员变量以及成员方法只能在本类中访问
可以修饰成员变量也可以修饰成员方法,就是为了外界不能直接访问.
被private修饰的成员变量/成员方法可以间接的通过访问方法间接访问.
Getter和Setter
当成员变量私有化之后,外界无法直接访问,所以需要提供对外公开的访问方式,来获取成员变量值和设置成员变量值。
手机事物
属性:品牌,颜色,价格,内存
行为:打电话,拍照,聊天
class Phone {
private String brand;
private int price;
private String color;
private int Memory;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getMemory() {
return Memory;
}
public void setMemory(int memory) {
Memory = memory;
}
public void call(){
System.out.println("打电话");
}
public void message(){
System.out.println("发短信");
}
public void game() {
System.out.println("打游戏");
}
public void movie(String name){
System.out.println("电影名:"+name);
}
public void show(){
System.out.println(getBrand()+","+getColor()+","+getMemory()+","+getPrice());
}
}
class PhoneTest {
public static void main(String[] args) {
//测试手机类
Phone s = new Phone();
s.setBrand("华为");
s.setMemory(512);
s.setBrand("华为matex");
s.setColor("黑色");
s.call();
s.message();
s.game();
s.movie("亮剑");
s.show();
}
}