IT十八掌大数据第三天
1. 1函数的含义
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。
1.2函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句；
return 返回值；
}
返回值的数据类型是由函数运行后的结果决定的
形参：是一个变量，用于存储函数调用时传递给函数的实际参数
实际参数：传递给形式参数的具体数值
return：用于结束函数
返回值 ： 该函数运算后的结果，该结果会返回给调用者。
**
对于函数没有具体返回值的情况，返回值类型使用关键字void表示， 如果该函数中的return语句如果在最后一行可以省略不写。
注意：
函数中只能调用函数，不可以再函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交给调用者处理。
函数在应用时需要明确
定义的函数最后的结果是什么
明确定义该功能的过程中，是否需要未知内容参与运算
定义一个函数实现两个整数相加
class FunctionTest {
public static void main(String [] args){
System.out.println(Sum(2,3));
}
public static int Sum(int a , int b){
return a+b;
}
}
此函数可以实现对Sum的调用
函数的重载
在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可
特点：
与返回值无关，只看参数列表
class FunctionTest {
public static void main(String [] args){
System.out.println(Sum(2,3));
System.out.println(Sum(2,3,4));
}
public static int Sum(int a , int b){ //定义两个参数
return a+b;
}
public static int Sum(int a, int b, int c){ //定义三个参数可以
return a+b+c;
}
}
数组 Array
----------------
概念 ： 同一种类型的数据的集合。（数组就是一个容器）
好处： 可以自动给数组中的 元素 从0开始编号，方便操作这些元素。
格式：
格式1
元素类型[] 数组名 = new 元素类型 [元素个数或者数组长度]
例：
int [] arr =new int [6] //表示的是 该元素为 int型， 元素的长度为6 （结果为有7个元素，因为从0开始）
格式2
元素类型[] 数组名 = new [] { 元素，元素……};
例：
int [] arr =new int []{1，2，3}；
int [] arr= {3,5,7,9};
class ArrayDemo {
public static void main(String[] args) {
int[] arr=new int [6];
int[] arr2=new int[]{1,2,3};
int [] arr3= {3,5,7,9};
System.out.println(arr.length); // 打印数组长度 arr.length是默认的属性
System.out.println(arr2.length);
System.out.println(arr3.length);
}
}
数组在内存中的形式
数组在内存中是连续的
下表从0开始 //访问数组的某个数字时 可以使用arr(下标) 来实现 如[1,2,3,4] arr[0] 即表示该数组的第一个数1.
//数组的长度为 arr[length] 数组中的最大值为arr[length-1]
数组中无arr[length]这个数字，如果访问的话会报错 //ArraIndexOutOfBoundException :数组越界异常
int[] arr=new int [6]; 共三步操作 1-定义一个int型数组2-在内存中开辟一个空间3-将两者关联起来
堆：heap
---------------
object heap
//数组处在堆区
// new建立的实例都处在堆内存中
//因为所有的对象都处在堆区中，所以如果堆设置的过小会放不下对象出现堆栈溢出（一般是栈溢出）
heap overflow 堆溢出
stack overflow 栈溢出
栈 stack
----------------
方法栈
方法栈至少对应一个线程（主线程main函数所在的线程）
栈中每一个方法叫做 一个方法帧 method frame
push stack : 压栈
pop stack :弹栈
java没有指针是指没有显式的指针操作。引用就是指针（变量的名称）
NullPointerException 是空指针异常（RuntimeException）//arr []=null; 属于运行时异常
练习；取数组中的最大值，并封装
class ArrayMax{ //类的名称一定要和文件编译后的名称一样，否则运行会报错。
public static void main(String[] args) {
System.out.println(getMax(new int []{2,5,21,5,7}));
}
public static int getMax (int [] arr){
//从健壮性考虑，应该考虑到arr==null和arr.length 长度为0。
if (arr == null|| arr.length==0){ //短路与先判断大的再判断小的
System.out.println("数组不存在");
return -1; //当为这两种情况时，提示错误，并返回一个-1的结果。
}
int temp =Integer.MIN_VALUE; //Integer.MIN_VALUE是整数型数字的最小值
for (int i=0; i < arr.length ; i++ ){
if (temp < arr[i]){
temp = arr[i] ;
}
}
return temp;
}
}
如果求数组中的最小值，之需要将Temp =Integer.MIN_MALUE换成---> Temp =Integer.MAX.MALUE, temp<arr(i)-->temp>arr(i)即可
对数组进行排序 （从小到大） 思想 迭代数组元素--查找最小值和最小值对应的角标--置换位置--返回数组--封装--调用
class ArraySelectSort{
public static void main(String[] args)
{
outArr(sort(new int []{2,1,6,4,9})); //调用数组
}
public static int[] sort(int[] arr){
if (arr == null|| arr.length == 0){ //排除为null和长度为0的情况
System.out.println("数组不存在");
}
//判断该数字往后的数字中的最小值
for (int i =0;i < arr.length ;i++ ){ //遍历数组中的所有数字
int aa=Integer.MAX_VALUE;
int index = 0 ; //定义角标的初始变量为0
for (int j= i + 1;j < arr.length;j++ ) {//遍历arr[i]数字后面的所有数字，求其中的最小值
if ( aa > arr [j]){
aa = arr [j]; //将较小的值赋值给Temp
index = j ; //获取较小值的角标
// System.out.println(aa) ;
}
}
//选出后面数字中的较小值时，如果比自身小，则调换位置
if (arr[i]>aa){
arr[index] = arr[i]; // 将arr[i]这个较大值赋值为arr[index],这里arr[index]充当一个中间量，此时arr[]为空
arr[i] =aa ; //然后将aa 赋值给已经是空值的arr[i] 实现两个数字的互换位置。
}
}
return arr; //返回arr 数组
}
public static void outArr (int [] arr){ //封装outArr 方法
for (int i = 0; i < arr.length ;i++ ){
System.out.print(arr[i]+" "); //打印 arr[i]这个数组
}
}
}
问题：
************************************************************************
为什么当 int aa=Integer.MAX_VALUE; 处在：
int index = 0 ;
处在：
for (int i =0;i < arr.length ;i++ ){ //遍历数组中的所有数字
上面时为什么是打印的结果是错误的。
*************************************************************************
冒泡排序
*****冒泡排序的话，该值会自动的跟下一位进行比较*****
所以 5，4，3，2，1 如果进行冒泡排序的话 只需要取到 arr[3]即可 ，arr[3]会自动的跟arr[4]进行比较。所以不需要取到arr[4]
举例：
使用大数下沉的方式 进行冒泡排序
class BubbleSort{
public static void main(String[] args) {
outArr(bubble(new int[]{ 3,6,8,2,1,5,9}));
}
public static int[] bubble (int [] arr) { //定义函数数组
//大数下沉的方式
for (int i = 0;i < arr.length - 1 ;i++ ){ //外层循环次数 为arr.length-1
for (int j = 0;j < arr.length - 1 - i ;j++ ){ //n内层循环次数为 arr.length-1-i
int temp= 0; //定义一个临时变量 用来接收数据
//数据的对调（因为是大数下沉的方式）
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr; //返回数组
}
public static void outArr(int [] arr){ //封装方法
for (int i=0 ;i<arr.length ;i++ ){
System.out.print(arr[i]+" ");
}
}
}
***************
for (int j = 0;j < arr.length - 2 - i ;j++ ){ //n内层循环次数为 arr.length-1-i
为什么-2 和 -1 结果相同
***************
折半查找
如果查找结果为10
1，3 ，5 ，7，8，10，11 进行折半的话 第一次折半的话为7，第二次进行折半的话为10（第二次从8开始）
折半查找 数据要有序
查找1-9数字中 6首次出现的位置。
class HalfFind{
public static void main(String[] args) {
System.out.println(find(new int []{1,2,3,4,5,6,7,8,9},6));
}
public static int find(int [] arr,int n){ //定义函数 *定义 一个int 型的数字
int a = 0 ;int b = arr.length ; int m = 0 ; //定义三个变量 【a b】角标 m （为中间量的值）
int mindex = 0; //中间量角标
//定义循环
while (a <= b){ //循环条件
mindex = (a + b) /2 ; //计算中间量的角标
m = arr[mindex]; //计算m的值
//判断m和
if ( m == n ){ //如果m 和查询值相等 注意是 “==”
return mindex;
}
//查询范围落在左边
else if(m > n){
b= mindex - 1;
}
//查询范围落在右边
else {
a = mindex + 1;
}
}
return - 1 ; //返回值
}
}
数组中的数组
---------------------
二维数组
格式1：
int [][] arr =new int [3][4]; //表示定义了一个名为arr的二维数组，该数组中有3个二维数组，每组4个元素
每一数组的名称分别为 arr[0],arr[1];arr[2];
如果给第一个数组的角标为1的 元素赋值的话写法为arr[0][1]= x;
格式2；
int[][] arr= new int[2][];
二维数组中有2个一维数组
每个一维数组都是默认初始化值null
可以对这个两个一维数组分别进行初始化
arr[0] = new int[3]; //第一个数组 有3个元素。
arr[1] = new int[1]; // 第二个数组 有1个元素。
打印倒置的二维数组
class MultiArray {
public static void main(String[] args) {
int [][] arr= new int[4][3]; //定义二维数组arr[4][3]
int a= 12; //定义一个数字从12开始
for (int i = 0;i<arr.length ;i++ ){ //定义外层函数 （有几个二维数组）
for (int j = 0;j<3 ;j++ ){ //定义内层函数（每个数组中有多少个元素）
arr [i][j] = a; //对第i行第j个元素赋值
a--; //自减1
}
}
outArr(arr); //调用
}
public static void outArr(int [][] arr){ //定义outArr 函数
for (int i = 0;i <arr.length ;i++ ){
for (int j=0 ;j< 3 ;j++ ){
System.out.print(arr[i][j]+"\t"); //打印arr[i][j]的数值
}
System.out.println();
}
}
}
/*
1 2 3 [0][0] [0][1] [0][2]
4 5 6 [1][0] [1][1] [1][2]
7 8 9 [2][0] [2][1] [2][2]
10 11 12 [3][0] [3][1] [3][2]
12 11 10 [3][2] [3][1] [3][0] [i][j]arr.length-1-i
9 8 7 [2][2] [2][1] [2][0] a--
6 5 4 [1][2] [1][1] [1][0]
3 2 1 [0][2] [0][1] [0][0]
*/
打印一个三阶魔方
class MultiArray{
public static void main(String[] args) {
int[][][] arr = new int[3][3][3]; //定义一个三维数组
int aa= 0;
// 对三维数组中的每一个元素赋值。
for (int i = 0;i < arr.length ;i++ ){ //定义魔方的层数
for (int j = 0;j < arr[i].length ;j++ ){ //定义魔方的行数 ,J的取值最大是arr[i].length,因为arr[i]在三维数组中也是一个数组所以有值
for(int q = 0;q < arr[i][j].length;q++){//定义[i][j]即第几层第一行的魔方列数
arr[i][j][q]= aa ; //将aa变量赋值给[i][j][q]这个元素.
aa++; //变量自增1
}
}
}
outArray(arr); //输出数组
}
//定义输出数组元素
public static void outArray(int[][][] arr){ // ***注意定义后面( )后面不带" ; " 自己易犯的错误。
for (int i = 0; i < arr.length ;i++ ){
for (int j = 0;j < arr[i].length ;j++ ){
for(int q =0;q < arr[i][j].length;q++){
System.out.print(arr[i][j][q]+"\t"); // 打印arr[i][j][q]元素的值，并增加一个空格 不换行
}
System.out.println(); //当输出完一行自动换行
}
System.out.println("********************");//当输出完一列后 打印分割线
}
}
}
/*
0 1 2
3 4 5
6 7 8
********************
9 10 11
12 13 14
15 16 17
********************
18 19 20
21 22 23
24 25 26
********************
*/
/*
1 2 3 [0][1][] * 10 11 12 [1][1][] * 19 20 21 [2][1][]
4 5 6 [0][2][] * 13 14 15 [1][2][] * 22 23 24 [2][2][]
7 8 9 [0][3][] * 16 17 18 [1][3][] * 25 26 27 [2][3][]
*/
面向对象 oop
----------------------
oriented object program : 面向对象编程
class ： 类 //类是对象的抽象，是对现实世界中事物的软件抽象（名词）
Object ： 对象 //是类的实例。 new 类名 （创建对象）
instance： 实例
面向对象是相对面向过程而言
面向对象和面向过程都是一种思想
面向过程
强调的是功能行为
面向对象
将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。
面向对象的特点
可以将复杂的事情简单化
完成需求时：
先要去找具有所需的功能的对象来用。
如果该对象不存在，那么创建一个具有所需功能的对象。
这样简化开发并提高复用。
面向对象的特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
类的属性也叫成员变量，
类的方法也叫成员函数。
成员变量
定义在类中，整个类都可以访问
随着对象的建立而建立，存在于对象所在的 堆内存中
成员变量有初始化默认值
局部变量
只存在于定义的局部范围内，如 函数，语句等
局部变量存在于栈内存中，
所用范围结束后，会立刻释放内存
无默认初始化值
构造函数 没有返回值 并且必须与类同名
public car （）{
}
默认的构造函数： ClassName ()
this :关键字，对象内部指向自身的一个指针。
函数的转置
class ArrayTrans{
public static void main(String[] args) {
int [][] arr={{1,2,3,},{4,5,6},{7,8,9,}}; //定义函数
out(arr); // 输出数组
System.out.println("*********************");// 为了对比效果 打印*来隔开
arr=trans(arr); //将trans 取arr数组的值
out(arr); //输出arr
}
//定义转置
public static int [][] trans(int [][] arr){
int temp = 0 ;
for (int i = 0; i<arr.length-1 ;i ++ ){ //定义数组的取值范围
for (int j = i+1; j < arr[i].length ;j++ ){ //定义数组列数
// 利用中间量的方法完成置换
temp = arr[i][j];
arr[i][j]= arr[j][i];
arr[j][i]= temp;
}
}
return arr;
}
//打印出arr[i][j]的值
public static void out(int[][] arr){ //定义out
for (int i = 0; i<arr.length ;i ++ ){
for (int j = 0; j < arr[i].length ;j++ ){
System.out.print(arr[i][j]+"\t"); //打印出arr[i][j]的值
}
System.out.println(); //换行
}
}
}
/*
1 2 3
4 5 6
7 8 9
***************************
1 4 7
2 5 8
3 6 9
*/
