Java基础知识第二部分（未完）
循环控制语句
1.do-while循环
do-while与while循环和for循环的最大区别：当条件不成立时至少执行一次
格式：
初始化语句；
do{
循环语句；
控制体语句；
}while（条件表达式）；
例：
int x = 6；
do{
System.out.println("helloJavaEE");
x++;
}while(x<6);2.for循环（死循环）
格式：
for（；；）{
循环体语句；
}
例：
for（；；）{
System.out.println("我很开心,学习了死循环....");
}执行流程：
1）初始化语句，给变量赋值（只执行一次）
2）然后执行条件表达式，看其是否成立，执行的是循环语句，然后再次回到控制体语句或者步长语句，变量自增或者自减；一直循环...............
3）一直执行到表达式不成立，for循环结束
典型例子：水仙花
public class Daffodil{
public static void main(String[] args) {
System.out.println("水仙花数是:") ;
// 1)三位数,明确了范围 100-999---使用for循环
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) ;
}
}
}
}3.while循环（死循环）
while死循环使用居多，当满足某个条件，结束循环--关键字break；结束中断（应用场景：switch，一个循环中）
格式：
while(true){
循环体语句；
}
例：
while（true）{
System.out.println("我很开心,学习了死循环....") ;
}执行流程：
首先,先初始化语句,对变量赋值;执行条件表达式,是否成立;成立,则执行循环体语句,依次控制体语句进行变量控制--->再次判断条件表达式是否成立,成立,执行循环体语句--->控制体语句进行变量控制 当条件表达式不成立,while循环结束; 注意事项: 控制体语句不要忘了,否则死循环;
while和for循环的区别：
相同点：能够描述一种循环思想,可以将重复性冗余代码进行优化,提供程序阅读性
不同点：1）格式不同
2）场景不同；
for循环：明确循环次数
while循环：不明确循环次数
3）是否节省资源；
for循环好处：循环结束之后，变量被释放
while循环：循环结束后，依然也能够使用这个变量，相对for循环格式来说比较耗费资源
4.Math随机数的使用
获取伪随机数，取值范围：[0.0:1.0）
public static double random():
*快速使用: Math.random() ----->获取一个随机数
典型例子：猜数字
import java.uilt.Scanner;
public class guessNumber{
public static void main(String[] args) {
//需要产生一个随机数:java.lang.Math 里面的功能random()产生一个1-100之间的随机数
int number = (int) (Math.random() *100 +1);
System.out.println(number) ;
int count = 0 ; //定义统计变量
while(true){ //不断的键盘录入
count ++; //只要进一次循环,count++
Scanner sc = new Scanner(System.in) ; //创建键盘录入对象
System.out.println("请您输入要猜的数字:") ;//提示并录入数据
int guessNumber = sc.nextInt() ;
if(guessNumber>100 || guessNumber< 0){ //使用guessNumber上面的随机数获取到的number进行对比
System.out.println("你要输入数据不合法,它是在0-100之间");
}else if(guessNumber> number){
System.out.println("你要猜的"+guessNumber+"大了") ; //如果大了,提示 "你要猜的数据大了"
}else if(guessNumber <number){
System.out.println("你要猜的"+guessNumber+"小了") ; //如果小了,提示"你要猜的数据小了"
}else{
System.out.println("恭喜您,第"+count+"次猜对了") ; //如果一致,提示"恭喜您,猜对了"
break ; //结束死循环
}
}
}
}
附：断点调试程序
在方法中的有效代码第一行大断点，在行号上直接单击即可使用debug启动Java程序
右键---->选择----->debug run xxx类名
5.for循环嵌套
格式：
for（初始化语句；条件表达式；控制题语句）{ //外层循环
循环体语句
for（初始化语句2；条件表达式2；控制题语句2）{ //内层循环
循环体语句
}
}
举例：9*9乘法表
public class Nn{
public static void main(String[] args) {
for (int x = 1; x <= 9; x++) {
for (int y = 1; y <= x; y++) {
System.out.print(x + "*" + y + "=" + (x * y) + "\t");
}
System.out.println();
}
}
}6.跳转控制语句
continue
for(int x= 1 ; x <=10;x++){
if(x %3==0){
}
System.out.println("******");
}
break
looper循环或者switch中用 (中断,结束...)
区别：
相同点：两个都在循环中使用居多；
不同点：1）break：结束中断，结束循环语句也可以结束switch语句，应用比continue广
2）continue：仅仅在循环中使用，表示结束当前循环，进入下一个循环
7.switch语句
格式：
switch(表达式或者某个变量值){
case 值1:
语句1;
break ;
case 值2:
语句2:
break ;
...
default:
语句n;
break ;
}执行流程：
switch接收结果,
1)接收的结果和case后面的值进行对比，与哪一句成立则执行哪一句,break 结束语句;
2)如果上面case都不匹配,执行default语句,break ,结束..
问：switch后面的跟的值的数据类型可以有哪些类型?
基本数据类型：byte，char，short，int
JDK5以后可以是枚举类型enum ：引用类型
JDK7以后可以是String字符串：引用类型
switch注意事项：
1）关于switch语句的case语句后面只能跟常量不能跟变量；（注：前端的javascript（弱类型语言，它里面的switch语句的case语句可以是变量也可以是常量）
2）在书写switch语句的时候不能忘记break，如果没有会造成case穿透（但有些需求需要case穿透来完成）；
3）switch结束条件：1）用break结束；2）程序默认执行到末尾；
4）default语句可以在switch的任何位置，不会影响程序执行；（如果default在句末，break可以省略；如果default在句中，break不能省略）
8.Java中定义方法的格式
1） 有返回值的方法
格式：
public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...){
//完成业务逻辑
return 结果;
}
调用该方法：
返回值类型 变量名= 方法名(实际参数1,实际参数2.....) ;2）无返回值的方法
格式：
public static void 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名2,....){
}
调用格式:
1)单独调用
2)输出调用
3)赋值调用
两个明确：
1)明确返回值类型 void
2)明确参数类型以及参数个数9.方法重载
为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关
例：
public static double getSum(double a,int b){}
public static double getSum(int a,double b){}
public static double getSum(double a,double b){}
public static int getSum(int a,int b,int c){}
1）它可以参数个数不同
2）参数类型不同
3）不考虑参数类型的顺序
10.数组
------> 一种容器，来储存同一类型的数据
两种格式：
数据类型[] 数组名称 ----->int[] arr
数据类型 数组名称[] ------>int arr[]
两种初始化：
1）动态初始化
数据类型 数组名称 = new 数据类型[数组长度]
------> int[] arr = new int[3];
int arr[] = new int[3];
2)静态初始化
数据类型 数组名称[] = new 数组类型[]{元素1，元素2，.........}
简写： 数据类型 数组名称[] = {元素1，元素2，.........}; ------->int arr[] = {1,2,3,.........};
注：初始化的时候不能动静结合，即不能同时静态和动态初始化，只能有一种。
数组特有属性：length
数组名称.length :获取数组长度
数组中最大索引值：数组名称.length-1
数组报错内容：java.lang.ArrayIndexOutOfBoundsException
原因：数组角标越界异常，访问了数组中的不 存在的索引就会出现这种问题;
数组的基本应用：
a.最值问题（最大/最小）
--------> 已知一个数组,静态初始化,完成获取数组中最大值
例：int[] array = {65,45,76,87,13} ; 求数组中的最大值
分析：
1)定义一个参照物 array[0]就是最大值
2)从角标1开始遍历数组的其他元素
3)判断:使用后面的元素依次和参照物比较，如果后面元素比参照物，将最大值修改了
4)获取最大值;
public static int getArrayMax(int[] arr){
//1)定义参照物
int max = arr[0] ;
//2)从角标1开始遍历数组,获取每一个元素
for(int x = 1 ; x < arr.length ; x ++){
//判断
if(arr[x] > max){
//将后面的元素赋值给max
max = arr[x] ;
}
}
return max ;
}
b.数组查表法
-------> 给定一个数组,快速获取数组中的某个元素:数组名称[索引值]
例：键盘录入一个数据:显示"星期*"
public class ArrayDemo {
public static void main(String[] args) {
//键盘录入一个数据
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数字(0-6):") ;
int num = sc.nextInt() ;
//已知字符串数组--->里面存储 了一些元素
String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
System.out.println("你查询的星期是:"+strArray[num]) ;
}
}c.数组中的基本元素查找法
查询元素的第一次出现的索引值,每次都需要从头查到尾（对于基本元素查找法的，数组的元素的内容,可以无序/可以有序）
例：已知一个数组int[] arr = {69,57,13,24,87} ; 查询数组中某个元素的索引值
分析：
1) 定义一个方法方法的返回值int，方法的参数类型和参数个数int[],查询的具体的元素2个参数
2) 遍历数组,获取所有元素---->判断:如果要查询的元素和数组的中元素一致,就找到了返回角标值
public class ArrayDemo2{
public static void main(String[] args) {
int[] arr = {69,57,13,24,87} ; //已知这个数组:
int index = getIndex(arr, 13);//找13 //调用方法
System.out.println("index:"+index);
}
//假设思想
public static int getIndex2(int[] array,int target){
//1)先定一个变量index:表示索引值
int index = -1 ; //假设角标找不到
//2)遍历数组array
for(int x = 0 ; x <array.length ; x ++){ //获取到每一个元素array[x]
if(target==array[x]){ //如果 target == array[x]:找到了,
index = x ; //将index修改
break ;
}
}
return index ;
}
}d.将数组进行逆序
例：将数组int[] arr = {69,57,13,24,87} ; 倒序排列
分析：
角标x = 0 ,
将arr[0]元素和arr[arr.length-1-0] 互换
arr[1]元素和arr[arr.length-1-1] 互换
arr[2]元素和arr[arr.length-1-2] 互换
...
...
需要保证数组长度 arr.length/2
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = {69,57,13,24,87} ;
getArray(array); //倒序
}
//遍历
public static void printArray(int arr[]){
System.out.print("int array=[");
for (int x=0;x< arr.length;x++){ //遍历数组
if (x== arr.length-1){ //角标x==arr.length-1表示数组最大索引值
System.out.println(arr[x]+"]"); //输出数组最后的元素
}else{
System.out.print(arr[x]+", "); //输出数组中间的元素
}
}
}
public static void getArray(int arr[]){
for (int x=0;x< arr.length/2;x++){ //arr.length/2--.>防止数组转回
int a=arr[x]; //给一个中间变量进行元素换位
arr[x]= arr[arr.length-1-x];
arr[arr.length-1-x] = a;
}
printArray(arr);
}
}e.冒泡排序:
两两比较,将较大的值往后放,第一次比较完毕,最大值出现在最大索引处;
依次这样比较,可以得到排好序的数组;
例：将这个数组int array[] = {1313,31313,1316,1311,31,164}; 进行排序
分析：
1)两两比较,将较大的值往后放
2)第一次有0个不比
第二次有1个不比
....
每次比较,就会减少一次比较(比较的次数:数组长度-1次)
public class ArrayDemo4 {
public static void main(String[] args) {
int[] arr = {69,57,13,24,87} ;
sortArray(array); //排序
}
//遍历
public static void printArray(int arr[]){
System.out.print("int array=[");
for (int x=0;x< arr.length;x++){ //遍历数组
if (x== arr.length-1){ //角标x==arr.length-1表示数组最大索引值
System.out.println(arr[x]+"]"); //输出数组最后的元素
}else{
System.out.print(arr[x]+", "); //输出数组中间的元素
}
}
}
public static void getArray(int arr[]){
public static void sortArray(int arr[]){
for (int x=0;x< arr.length-1;x++){ //循环次数
for (int y=0;y< arr.length-1-x;y++){
if (arr[y]>arr[y+1]){
int b = arr[y];
arr[y] = arr[y+1];
arr[y+1] = b;
}
}
}
printArray(arr);
}
}11.面向对象
面向对象的思想特点：
1）更符合生活中的思想行为习惯
2）让复杂的事情简单化
3）让我们从执行者变成指挥者
面向对象的三大特征：封装 继承 多态
什么是类？
类是描述现实世界事物的一组属性和行为的集合; ----->事物一定是真实存在的
格式：
class 类名{ //类名:满足标识符的规范: 见名知意
数据类型 变量名； //成员变量：在类中方法外定义的变量
}
//成员方法
//第一种
public 返回值类型 方法名(参数类型1 变量名1,...){
//业务逻辑
return 结果;
}
//第二种
public void 方法名(参数类型1 变量名1,...){
//业务逻辑
直接输出
}基本类型作为形式参数和引用类型:
1) 基本类型作为形式参数，形式参数不影响实际参数
局部变量:生命周期:随着方法调用而存在,随着方法调用结束而结束;
2) 引用类型作为形式参数，形式参数的改变直接影响实际值 (除String类)
public class ArgsDemo {
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
System.out.println("a:"+a+",b:"+b) ;//a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b);//a:10,b:20
System.out.println("-----------------------------------") ;
int[] arr = {1,2,3,4,5} ; //new int[]{1,2,3,4,5} ;
System.out.println(arr[1]) ;//2
change(arr) ;
System.out.println(arr[1]) ;//4
System.out.println("------------------------------------------");
//在引用类型String特殊类型:是一个常量
//String作为形式参数,和基本类型作为形式参数是一样,形式参数的改变不会影响实际参数;
String s = "helloworld" ;
System.out.println(s); //helloworld
change(s) ;
System.out.println(s);//hellworld
}
public static void change(String s){
s+= "高圆圆" ;
// System.out.println(s);
}
public static void change(int a,int b){//形式参数 :10,20 基本类型
a = b ; // a = 20
b = a + b ; // b = 20 + 20 ;
}
public static void change(int[] arr){ //形式参数: 引用类型 数组格式 :传递实际就是数组对象:就是那个空间地址值
for(int x = 0 ; x < arr.length ; x ++){
if(arr[x] %2 ==0){
arr[x] *=2 ; //
}
}
}
}
12.封装
就是将显示世界事物的属性隐藏了(加入一个关键字private)私有的,无法直接访问的,对外数据的安全性!(外界不能访问的) 对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())
注意事项：
以后在书写的代码的时候,写一个类,描述真是存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private
private关键字的特点：
1)被private修饰的成员变量以及成员方法只能在本类中访问
2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
3)被private修饰的成员变量/成员方法可以间接的通过通过的方法访问;
//定义一个学生类:来描述学生事物
public class Student {
//被private修饰的成员变量:只能在本类中访问,外界不能访问
//属性私有化
private String name ; //姓名
private int age ; //年龄
private String sex ;//性别
//手写 ---公共的访问方法:给姓名,年龄,性别 赋值
//setXXX():XXX就是属性名称 ,符合标识符的规范
public void setName(String n) { //方法需要形式参数: 等会传递"高圆圆"
name = n ;//把n的值赋值给成员变量name
}
//给年龄赋值
public void setAge(int a){
age = a ;
}
//给性别赋值
public void setSex(String s){ //"女"
sex = s ; //sex = "女"
}
//提供公共的getXXX():获取姓名,年龄,性别
//获取姓名
public String getName(){
return name ;
}
//获取年龄
public int getAge(){
return age ;
}
//获取性别
public String getSex(){
return sex ;
}
//成员show(),来展示学生信息
/* public void show(){
System.out.println("学生的姓名是:"+name+",年龄是"+age+",性别是:"+sex);
}*/
//学习JavaSE
public void studyJavaSE(){
System.out.println("正在学习JavaSE之面向对象oop");
}
// 会敲代码
public void codding(){
System.out.println("每天日日夜夜敲代码...");
}
}
//Student测试类
public class StudentTest {
public static void main(String[] args) {
//描述具体的学生---创建学生对象 :类名 对象名 = new 类名();
Student s = new Student() ;
//对象名.成员变量 = 赋值; //赋值这些值 肯定来数据库
//s.name = "****" ; //被private修饰的成员变量:只能在本类中访问,外界不能访问
// s.age = 20 ;
// s.sex = "男" ;
//使用对象名.成员方法名() ;
//给学生的信息赋值---调用setXXX()
s.setName("***") ;
s.setAge(20) ;
s.setSex("男") ;
System.out.println("学生的姓名是:"+s.getName()+",年龄是"+s.getAge()+",性别是:"+s.getSex());
//调用这个学生的一些其他行为
s.studyJavaSE();
s.codding();
}
}
55
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
