一.选择结构(Switch)
switch循环：
选择结构语句之switch
格式:
switch(表达式或者某个变量值){
case 值1:
语句1;
break ;
case 值2:
语句2:
break ;
...
default:
语句n;
break ;
} 执行流程
switch接收结果,
1)接收的结果和case后面的值1进行对比,成立,执行语句1,break 结束语句;
2)值1和switch接收的结果不匹配,和值2进行比较,成立,执行语句2, break,结束语句;
3)如果上面case都不匹配,执行default语句,语句n,break ,结束...
switch语句中的注意事项也是 (考点)
1)关于switch中的case语句后面只能常量,不能是变量 (体现Java是一种强类型语言)
前端的javascript(弱类型语言):它里面的swtich的case是可以是变量,可以是个常量
2)在书写switch语句的标准结构,不忘了break,如果语句中忘了书写break,会出现一个现象:case穿透!
在有的需求里面利用 case穿透 来完成一些需求;
3)关于switch语句的结束条件
a)要么遇见break结束
b)程序默认执行到末尾
4)关于default语句可以在switch语句中的任何位置,不影响语句的执行流程;
不管在任何位置,只要case语句都不匹配,执行default;
如果default语句在语句中,break不要省略
如果default语句的末尾,break可以省略;
面试题:
switch后面的跟的值的数据类型可以有哪些类型?
基本数据类型:byte,short,int,char
jdk5以后可以是枚举类型 enum:引用类型
jdk7以后可以是String字符串 :引用类型
二.循环结构语句和随机数的产生
1.for循环
格式
for(初始化语句;条件表达式;控制体语句或者步长语句){
循环体语句;
}
执行流程
1) 初始化语句:给变量赋值 (只执行一次)
2)然后执行条件表达式,看其是否成立,如果成立,执行的是循环体语句------>再次回到控制体语句或者步长语句--->变量自增或者自减
3)再次执行条件表达式,是否成立,成立,继续循环体语句---->再次回到控制体语句或者步长语句---->变量自增或者自减
4)一直执行到条件表达式不成立,for循环结束;
for循环的综合运用（嵌套）
for(初始化语句1;条件中表达式1;控制体语句1){
循环体语句
for(初始化语句2;条件表达式2;控制体语句2){
循环体语句
}
}2.while循环：
while循环的格式
经常使用的格式
初始化语句;
while(条件表达式){
循环体语句 ;
控制体语句或者步长语句;
}
执行流程:
首先,先初始化语句,对变量赋值;
执行条件表达式,是否成立;成立,则执行循环体语句,依次控制体语句进行变量控制--->再次判断条件表达式是否成立,成立,执行循环体语句--->控制体语句进行变量控制
当条件表达式不成立,while循环结束;
注意事项:控制体语句不要忘了,否则死循环;
for循环和while循环的区别
共同点:都是能够体现循环思想,解决代码冗余问题
不同点:
1)格式不同
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
2)使用场景不同
for循环(普通for循环),明确循环次数优先采用for (实际开发中for使用很频
繁:遍历数组,获取数组的元素)
后期学习特殊for循环(增强for循环--->集合 中使用频繁的)
while循环: 不明确循环次数使用while循环
3)从内存角度是否节省内存
for循环的这种格式,比较节省内存资源,当for循环结束,里面的变量被释放了,
这个变量作用域就在 for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
while循环,相对for循环,比较消耗内存,当while循环,依然能够访问变量
for和while
while在死循环中使用多一些
3.流程控制语句
break 结束程序
continue 结束本次循环
return 返回值
1.死循环
利用死循环完成一些需求,死循环中肯定需要使用逻辑判断;
当达到某种条件的时候,应该结束死循环;
2.产生随机数：
jdk提供了类:java.lang.Math
java.lang包下的类不需要导包
针对数学运算的工具类,提供了很多的方法;
获取伪随机数,取值范围:[0.0,1.0)
public static double random():
快速使用:
Math.random()---获取一个随机数
格式
double number = Math.random();
三.Java中的方法
方法
给某段代码,使用{}包裹起来,给这个{}起一个名字,方法名,就可以有相同业务逻
辑代码,直接使用方法名调用,提高代码的复用性;
注意事项
写代码,以后不能把所有的东西都放在main方法中写
方法定义格式
有具体返回值方法的定义格式
固定写法:
public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参
数名2,....){
//完成功能业务逻辑
...
return 具体结果;
}
有具体返回值类型的方法的调用格式
结果类型 变量名 = 方法名(实际参数1,实际参数2,...)
实际参数:直接赋值或者main中键盘录入
没有具体返回值类型的方法定义格式
public static void 方法名(形式参数类型1 变量名1,参数类型2 变量名2){
}
调用格式:
单独调用
方法名(实际参数1,实际参数2.....) ;
3.方法重载
方法名相同,参数列表不同,与返回值无关的这些方法;
参数列表不同:
参数个数不同
参数类型不同
参数类型的顺序
四.数组及其定义方法和数组的使用
数组是一种容器 ,容器只能存储同一种类型的元素
特性
1）所有的数组有一个特点:数组名称[角标或者索引值]:访问数组的元素 ,角标值/索引值从0开始计算
在数组中有一个特有的属性:length
2）数组名称.length:获取数组长度
数组中的最大索引值: 数组名称.length-1
数组的定义格式
1.数据类型[] 数组名称;
int[] arr ; //定义了一个int类型的数组arr变量
2.数据类型 数组名称[] ;
int arr[] ; //定义了一个int类型的arr数组变量初始化两种
1)动态初始化
数据类型[] 数组名称 = new 数据类型[数组长度];
int[] arr = new int[3] ;
int arr[] = new int[3] ;
2)静态初始化
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2....} ;
简写格式
数据类型[] 数组名称 = {元素1,元素2....} ;// int[] arr = {11,22,"hello"}; //静态初始化 错误的
int[] arr = {11,22,33} ;
数组的使用
class Demo{
public static void main(String[] args){
//已知一个数组
int[] arr = {87,56,13,24,17}; //创建一个数组
// int[] arr = new int[]{87,56,13,24,17}
//调用方法
printArray(arr) ; //arr是空间地址值}
//[元素1, 元素2, 元素3, ....元素n]
//定义一个方法
//直接输出,没有返回值类型 :void
//参数类型: 数组类型
public static void printArray(int[] array){
//实际要具体的数组(创建一个数组对象) :传递一个空间地址值
System.out.print("[") ;
//遍历数组
for(int x = 0 ; x < array.length ; x ++){
//获取到每一个元素了
//判断
//如果角标x == array.length-1
if(x==array.length-1){
//输出最后元素 以及有中括号 元素n]
System.out.println(array[x]+"]") ;
}else{
//中间的元素
//元素1, 元素2, 元素3,
System.out.print(array[x]+", ") ;
}
}
} 定义一个数组的内存的流程
int[] array = new int[3] ; 这句话完了哪些事情? ----内存干了什么事 情
1)需要在栈内存中开辟 空间, int[] array这个变量
2)new int[3] ; 需要在堆内存中申请空间
3)为这个堆内存中的这些数组的元素,进行系统默认初始化,int类型的元素在
数组中默认值0
4)系统初始化完毕,为堆内存空间产生一个空间地址值,
5)将堆内存空间地址值赋值给栈内存的变量array
6)栈内存变量 array指向堆内存地址;
冒泡排序
例子
package com.qf.edu.Test.Second;
public class MaoPao {
public static void main(String[] args) {
int[] arr = {68,73,13,16,19,91,25,55};
bubbleSort(arr);
printArray(arr);
}
public static void bubbleSort(int[] arr ){
for (int m=0;m< arr.length-1;m++){
for (int n=0;n<arr.length-1-m;n++){
if (arr[n]>arr[n+1]){
int temp = arr[n];
arr[n] = arr[n+1];
arr[n+1] =temp;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
for (int x=0;x<arr.length;x++){
System.out.print(arr[x]);
if (x<arr.length-1){
System.out.print(",");
}else {
System.out.print("]");
}
}
}
}
求最值问题
package com.qf.edu.Test.Third;
public class Third {
public static void main(String[] args) {
double[] arr ={12.9,53.54,75.0,99.1,3.14};
zuiDa(arr);
}
public static void zuiDa(double[] arr){
double min =arr[0];
for (int x=0;x< arr.length;x++){
if (min>arr[x]){
min = arr[x];
}
}
System.out.println("最小值为："+min);
}
}
逆序
package com.qf.edu.ShuZu;
public class ArrayDemo02 {
public static void main(String[] args) {
int[] array ={45,56,62,59,98,22};
arr1(array);
}
public static void arr1(int array[]){
for (int x=0;x<array.length/2;x++){
int temp =array[x];
array[x]=array[array.length-1-x];
array[array.length-1-x]=temp;
}
for (int c=0;c<array.length;c++) {
System.out.print(array[c]+" ");
}
}
}
五.面向对象
面向对象的思想和概念
思想：
前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应
的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将
这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？
通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作
时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
面向过程
我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后
我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，
完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直
接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程
完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能， 进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
面向对象的思想特点：
面向对象是基于面向过程的编程思想
1. 是一种更符合我们思想习惯的思想
2. 可以将复杂的事情简单化
3. 将我们从执行者变成了指挥者
面向对象的三大特征:
封装,继承,多态 (整个java最重要的)
类和对象
类是能够描述现实世界事物一组属性和行为的集合;
类和事物的关系:一一对应的关系
事物一定现实真实存在的
定义类的格式：
class 类名{ //类名:满足标识符的规范: 见名知意
1.基本类型作为形式参数和引用类型 (数组,类,接口) 作为形式参数的特点(重点)
基本型作为形式参数,形式参数改变不影响实际参数;
引用类型作为形式参数,形式参数的改变直接影响实际参数;
封装private
如果学生的年龄,手机价格,,赋值的时候可以随便赋值,可能出现非法数据"负数"
封装
就是将显示世界事物的属性隐藏了(加入一个关键字private), 私有的,无法直接访问的,对外数据的安全性!(外界不能访问的) 对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())
注意事项:
以后在书写的代码的时候,写一个类,描述真是存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private 描述事务的时候，需要定义类，类中的所有的成员变量（现实世界事物的属性) ,必须都是私有化private;
private关键字的特点
1)被private修饰的成员变量以及成员 方法只能在本类中访问
2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
3)被private修饰的成员变量/成员方法可以间接通过的方法访问
使用
//Demo类
class Demo{
//没有加入private
int num = 20 ;
//私有的
private int num2 =30 ;
//通过公共访问访问私有成员变量
public void show(){
System.out.println(num);
System.out.println(num2); //间接访问私有成员变量
}
//一个成员方法: 以后说的成员方法 都不能static
public void method(){ //公共的
//局部变量:修饰符根据我们的方法的权限来确定 ,局部变量一般都是默认修饰符
//private int x = 10 ;
System.out.println("method Demo...");
System.out.println("-----------------------");
function(); //间接调用私有方法了
}
//私有方法
private void function(){
System.out.println("function Demo...");
}
}
//测试类
public class PrivateDemo {
public static void main(String[] args) {
//访问Demo类的成员变量
//在一个类中访问另一个类东西,需要创建对象
//类名 对象名 = new 类名();
Demo d = new Demo();
System.out.println(d.num);
//System.out.println(d.num2);//num2' has private 私有
//访问Demo类的成员方法
//对象名.成员方法名()
d.method();
// d.function();//function()' has private
d.show();
}
}
497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
