跳转控制语句break,continue,return
break:表示结束中断,;单独使用没有意义,一般只能在switch或者循环语句中使用
contiue:结束当前循环,立即进入下一个循环,单独使用没有意义,contiue在loop外部循环使用
return:一般很少单独去使用,一般结束方法用的
方法
1.概念:就是使用{}包起来的内容,给{}包起来的 代码块起一个名字一边服用,定义一个方法
2.定义方法的格式:
第一种情况:有返回值类型的方法
权限修饰符 静态修饰符 返回值列表 方法名(形参列表){
方法体;
return 结果;
}
第二种情况:没有具体返回值类型:
权限修饰符 静态修饰符 返回值列表(void) 方法名(形参列表){
方法体;
}
解释格式:
权限修饰符:public 公共的公开的,访问权限最大
静态修饰符:static
返回值类型:数据类型(目前基本数据类型)
方法名:给{}里的代码块起一个名字,方法名要遵守见名起义
形式参数: 数据类型 :目前基本数据类型
变量名:要符合标识符的规则
return:表示结束方法,调用方法的时候给具体返回结果,如果没有return报错
3.定义方法的两个明确
1)明确返回值类型
2)明确参数类型以及蚕食个数
4.调用方法
1)有返回值类型的调用
a.单独调用:没有意义
b.输出调用:直接去使用了,不利于后期对该结果的操作
c.赋值调用
2)没有返回值类型调用
没有返回值类型的方法,只能用单独调用
5.方法重载
方法名相同,参数列表不同与返回值无关
参数列表不同:
1)要么类型不同
2)要么参数个数不同
数组
1.概念:是一种容器,可以存储同一种类型元素的一种容器
2.数组的定义:数据类型[] 数组名称
数据类型 数组名称[]
3.数组的两种初始化
动态初始化:开发者定义数组初始化的时候,指定数组的长度,系统默认给数组中的元素赋值
静态初始化:直接指定数组的原不俗内容,系统指定的数组长度
4.动态初始化
数据类型[] 数组名称=new 数据类型[数组长度]
数据类型 数组名称[]=new 数据类型[数组长度]
5.静态初始化
1)概念:指定的元素的内容,系统默认长度
2)格式:数据类型[] 数组名称=new 数据类型[] {元素1,元素2,元素3…}
数据类型[]={元素1,元素2,元素3…};
6.元素逆序
class ArrayTest3{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {57,87,96,13,24} ;
//在逆序之前,先去遍历这个数组(将元素一一打印)
System.out.println("逆序之前:") ;
printArray(arr) ;
//逆序
//调用逆序的功能
//reverse(arr) ;
reverse2(arr) ;
//遍历一下
System.out.println("逆序后:");
printArray(arr) ;
}
/
public static void reverse2(int[] arr){
//在一个for循环中定义一个两个变量
//start:表示开始索引
//end:最终最大索引
for(int start = 0,end = arr.length -1 ; start<=end ;start ++,end -- ){
//中间第三方变量
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
7.数组查表法
通过数组名称[角标值]确定内容
数组的基本查找发:从数组中的开始索引一直查询到末尾,查询出元素第一次在数组中的数值
class ArrayTest5{
public static void main(String[] args){
//定义数组,静态初始化
int[] arr = {87,200,300,450,96,24} ;
//查询4500这个元素在数组中的索引值:
int index = getIndex(arr,4500) ;
System.out.println(index) ;
System.out.println("----------------");
int index2 = getIndex(arr,96) ;
System.out.println("index2:"+index2) ;
System.out.println("----------------");
int index3 = getIndex(arr,240) ;
System.out.println("index3:"+index3) ;
}
//方式2:假设法:
public static int getIndex2(int[] arr,int key){
//假设元素找不到
//定义一个变量
int index = -1 ;
//遍历数组arr
for(int x = 0 ; x < arr.length ; x ++){
//获取到每一个元素
if(arr[x] == key){
//将index的值更改掉
index = x ;
break ;
}
}
return index ;
}
/*
定义查询角标的方法
两个明确
1)明确返回值类型:int
2)明确参数类型以及参数个数
int的数组以及int类型的元素,2个参数
*/
//参数1:在已知的数组中查询元素
//参数2:在arr数组中查询key这个元素
public static int getIndex(int[] arr,int key){
//1)遍历arr数组
for(int x = 0 ; x < arr.length ; x ++){
//获取到每一个元素
//判断:如果arr[x] == key ---- >查找到这个元素,返回角标值
if(arr[x] == key){
return x ;
}
}
//对于判断:要么成立,要么不成立 (成立,表示查询到了)
//如果元素没有在数组中出现,查不到,要考虑返回某个值 "负数" 一般找不到:-1
return -1 ;
}
}
8.冒泡排序(重点)
思想:两两比较,较大的值往后放,第一次比较完毕,最大值就出现最大索引位,依次这样比较,就可以得到一个排好序的数组
class ArrayTest{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {57,69,80,13,22} ;
//需求:遍历arr数组,最终以 [元素1, 元素2, 元素3, ....元素n]格式出现 变成功能
//调用
printArray2(arr) ;
printArray2(arr2) ;
}
//最终版代码:遍历数组
public static void printArray2(int[] array){
//拼接左中括号
System.out.print("[") ;
//遍历array数组
for(int x = 0 ; x < array.length; x ++){//x角标
//获取到每一个元素
//判断:如果x取到最大索引值,---->取到最后一个元素了
if(x==array.length-1){
//最后一个元素,输出元素内容以及右中括号
System.out.println(array[x]+"]") ;
}else{
//不是取到最大索引值,将中间的元素按照按照格式输出(元素+逗号+空格)
System.out.print(array[x]+", ") ;
}
}
}
/*
遍历的功能
定义一个方法
两个明确
1)明确返回值类型:void
2)明确参数类型以及参数格式
int类型的数组 1个参数
*/
public static void printArray(int[] array){//方法的形式参数:传递的是一个引用类型:数组
for(int x = 0 ; x < array.length ; x ++){
System.out.println(array[x]) ;
}
}
}
二维数组
1.概念:其实就是一个元素为一维数组的数组
2.定义格式:
数据类型[] 数组名称[];
数据类型[][] 数组名称
3.动态初始化
格式一:
数据类型[][]数组名称 =new 数据类型[m][n]
格式二:
数据类型[][]数组名称 =new 数据类型[m][]
格式三:(静态初始化)
数据类型[][] 数组名称=new 数据类型[][]{{元素1,元素2,元素3},{元素1,元素2,元素3}。。。。}
4.二维数组的遍历
class Array2Test{
public static void main(String[] args){
//定义一个二维数组,静态初始化:
int[][] arr = {{1,2,3},{4,5},{6}};
//调用遍历的功能
printArray2(arr) ;
}
/*
两个明确
1)明确返回值类型:void
2)明确参数类型以及参数个数
1个参数 int类型二维数组
*/
public static void printArray2(int[][] arr){
//输出以下左大括号
System.out.print("{");
//遍历
for(int x = 0 ; x < arr.length; x++){//外层循环是一维数组的个数
//先输出左大括号
System.out.print("{");
//遍历一维数组的元素
for(int y = 0 ; y < arr[x].length ; y++){
//判断
//如果是二维数组的最后一个元素
if(x == arr.length-1){
//输出元素值以及后面的}
System.out.print(arr[x][y]+"}") ;
//如果当前元素取到的一维数组的最后一个元素
}else if(y == arr[x].length-1){
//输出元素内容以及}以及,
System.out.print(arr[x][y]+"}"+",") ;
}else{
System.out.print(arr[x][y]+",") ;
}
}
}
//输出整个右}
System.out.print("}");
}
}
面向对象
面向对象的思想特点:
1)更符合生活中的思想行为习惯
2)让复杂的事情简单化
3)让我们从执行者变成一个指挥者
面向对象的设计原则:
创建对象,是想对象,指挥该对象做东西
面向对象的三大特征
封装,继承,多态
类和事物
事物:描述现实世界的真实存在的泛指的东西
类:是描述一组事物的属性和行为的集合
学生事物---------->代码体现出来:类:学生类 classStudent
属性:描述学生的特征(姓名,年龄,学号,性别)成员变量 位置:在类中方法外
行为:描述学生能干什么 成员方法(去掉static)
public 返回值类型 方法名(){}
代码体现具体事务:创建该类对象
类名 对象名=new 类名();
对象名.成员变量
对象名.name=“张三”;
对象名.成员方法
局部变量和成员变量的区别
1)在类中的位置不同
局部变量:在方法中定义或者方法上声明的变量
成员变量:在类中方法外的变量
2)在内存中的位置不同
局部变量:在栈内存中存储
成员变量:在堆内存中存储
3)生命周期不同
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完毕等待垃圾回收器回收才消失
4)初始化时机不同
局部变量:必须在使用之前对数据进行初始化,否则“可能尚未初始化变量”
成员变量:跟对象有关系,在堆内存中,即使这个成员变量设有赋值,系统也会根据变量的类型给这数据进行初始化
封装
概念:将类中成员变量私有化,对外提供公共的访问方法
private的特点:
1)private可以修饰一个类中的成员变量,也可以是成员方法
2)被private修饰的成员变量或者成员方法只能在本类中访问,外界是不能访问的
构造方法
概念:方法名和类名相同,没有具体的返回值类型,并且连void都没有
格式:public 类名(){}
作用:就是给该对象中的数据进行初始化
static修饰符
静态的特点:
1)被static修饰的变量/方法都随着类的加载而加载
2)被static修饰优先于对象存在
3)被static修饰的可以被多个对象使用
4)被静态修饰的成员变量或者成员方法可以被类名直接访问,但是也可以用该类对象访问该成员
关于成员方法的访问问题:
非静态的成员方法:
既可以访问静态的成员变量,也可以访问非静态的成员变量
既可以访问静态的成员方法,也可以访问非静态的成员方法
静态的成员方法
静态只能访问静态
面试题
Student s=new Student()做了那些事情?(从内存角度来说)
1)加载studengt.class进内存
2)在栈内存中开辟栈内存空间
3)在堆内存中申请空间
4)对数据进行初始化
a.系统默认初始化
b.显式初始化------setxxx(形参)构造方法赋值
5)堆内存中申请空间完毕,产生一个堆内存地址
6)将堆内存地址赋值给栈内存变量s
7)栈内存变量s堆内存地址
什么时候将变量定义为成员变量
如果这个变量能够描述当前类(事物)的属性的话,这个时候将变量定义为成员变量;否则就是局部变量
实际开发中,变量的范围越小越好(局部变量)