JAVA自学笔记06

JAVA自学笔记06

1、二维数组
1）格式：
①数据类型[][]数组名 = new 数据类型[m][n];
或 数据类型[]数组名[]=new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每个一维数组的元素个数
存储图解：

eg:int[][]arr = new int[3][3];
意义：定义了一个二维数组名为arr，这个二维数组有3个一维数组，名称是arr[0]、arr[1]、arr[2],每个数组有3个元素，可通过arr[m][n]来访问相应m+1、n+1元素
区分：
int[] x,y[];//x是一维数组，y是二维数组。

@例题1：定义一个二维数组

int[]x[]=new int[3][2];
System.out.println(x);//输出二维数组的名称

System.out.println(x[k]);//输出二维数组的第k+1个一维数组的名称

②数据类型[][]变量名=new 数据类型[m][];
意义：m表示这个二维数组有多少个一维数组,但没有直接给出一维数组的元素个数，可以不一样。
eg:int[][]arr=new int[2][];
arr[0]=new int[3];
arr[1]=new int[7];
存储图解：

@例题3 写出下列程序的结果
int[][]arr=new int[2][];
arr[0]=new int[3];
arr[1]=new int[2];

System.out.println(arr);//输出地址
System.out.println(arr[0]);//null，下同
System.out.println(arr[1]);

arr[0]=new int[3];
//开辟空间
arr[1]=new int[2];
System.out.println(arr[0]);//地址值，下同
System.out.println(arr[1]);

③前两种格式都是动态初始化，这是静态初始化
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},…}；
简化格式：数据类型[][]变量名={{元素…},{元素…},…}
；
eg:int[][] arr={{1,2,3},{34,34}};
存储图解

2）二维数组的遍历
int [][]arr={{1,2,3},{34,34}};
for(int x=0;x

class Sum{
public static void main(String args[]){
int[][] arr={{22,66,44},{23,43,11},{43,22,34},{44,33,22}};
int sum=0;
for(int x=0;x<arr.length;x++){
for(int y=0;y<arr[x].length;y++){sum+=arr[x][y];
}
}
System.out.println(sum);
}
}

@例题4：键盘录入行数，屏幕输出杨辉三角形

import java.util.Scanner;

class Array2Test3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据：");
        int n = sc.nextInt();

        //定义二维数组
        int[][] arr = new int[n][n];

        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }

        //按照规律给其他元素赋值
        //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的，就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始，因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }

        //遍历这个二维数组。
        /*
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {
                System.out.print(arr[x][y]+"	");
            }
            System.out.println();
        }
        */
        //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"	");
            }
            System.out.println();
        }
    }

2、参数传递
例题5:看程序写结果

class ArgsDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); 
        change(a,b);//a=10,b=20
        System.out.println("a:"+a+",b:"+b); 

        int[] arr = {1,2,3,4,5}; 
        change(arr);
        System.out.println(arr[1]); 
    }

    public static void change(int a,int b) { //a=10,b=20
        System.out.println("a:"+a+",b:"+b); //a:10,b:20
        a = b;  //a=20
        b = a + b; //b=40
        System.out.println("a:"+a+",b:"+b); //a:20,b:40
    }

    public static void change(int[] arr) { //arr={1,2,3,4,5};
        for(int x=0; x<arr.length; x++) {
            if(arr[x]%2==0) {
                arr[x]*=2;
            }
        }
        //arr={1,4,3,8,5};
    }
}

基本类型：形式参数的改变对实际参数没有影响
引用类型：形式参数的改变直接影响实际参数
图解：
（方法在栈内执行）

@例题5：某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。

class Test{
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);


        System.out.println("请输入一个密码(不大于八位)：");
        int n = sc.nextInt();
        int[] arr=new int[8];
        int index=0;

        for(;n>0;n=n/10) {
            arr[index]=n%10;
            arr[index]+=5;
            arr[index]%=10;
            index++;
        }
        int temp=arr[index];
        arr[index]=arr[0];
        arr[0]=temp;

        for(int i=0;i<index;i++) {
            System.out.print(arr[i]);
        }
    }
}

3、面向对象
1）面向对象就是不断创建对象，指挥对象做事情
2）面向对象设计：管理和维护对象之间的关系
3）面向对象的特征：封装、继承、多态
4）类与对象的关系：属性、行为 ，JAVA中最基本的单位是类
事物：属性、行为
类：成员变量、成员方法（初学者把static 先去掉） ，与之前的变量、方法格式并无区别
类是一组相关的属性和行为的集合，是一个抽象的概念
对象是该类事物的具体表现形式，具体存在的个体

4、对象
1）创建对象：类名 对象名=new 类名();
2）使用成员变量：对象名.变量名
使用成员方法：对象名.方法名(参数列表);
3)赋值：对象名.变量名=
4)内存图解（一个对象）：

5）两个对象

6）成员变量和局部变量的区别
①类中的位置不同：类中方法外/方法内或方法声明上
②内存中的位置不同：堆内存/栈内存
③生命周期不同：随着对象的存在而存在，随着对象的消失而消失
/随着方法的调用而存在，随着方法调用完毕而消失
④初始化值不同：成员变量：有默认的初始化值
局部变量：没有默认的初始化值，必须先定义，赋值，才能使用

局部变量名称可以与成员变量名称相同，在方法中使用采用的是就近原则、

@例题6：学生类的定义与使用

class Student{
//定义变量
String name;
int age;
String address;
//定义方法
public void study(){...;}
public void eat(){...;}
public void play(){...;}
}

/*使用（在一个java文件中写两个类，一个基本的类，一个测试类。文件名应与测试类名称一致）*/
class Test{
public static void main(String args[]){
Student s = new Student();
//创建对象,s.name=null,s.age=0,s,address=null
s.name="jack";
s.age=23;
s.eat();
s.sleep();
} 
}

5、形式参数
1）基本类型、引用类型
2） 类是引用类型
3）方法的形参是类名的时候如何调用？
如果一个方法的形式参数是一个类类型（引用类型），这里需要的是该类的对象

6、匿名对象
1）没有名字的对象：
eg：new 类名();
2)应用场景：
①调用方法，仅仅只调用一次的时候
优点：匿名对象调用完毕后即被回收
eg: new 类名().方法名();
②可作为实参传递
方法名(new 类名());
new StudentDemo().method((new Student());
上述例子中：构造了两个匿名对象，可用于调用方法。

7、封装
1）概述：指将隐藏对象的属性和实现细节，仅对外提供公共访问方式
2）优点：①隐藏实现细节，提供公共访问方式
②提高代码复用性
③提高安全性
3）原则：将不需要对外提供的内容都隐藏起来且把属性隐藏，提供公共方式对其访问
4）关键字：private
被private修饰的成员变量及方法仅能在本类中访问

8、private 关键字
1）权限修饰符，可修饰成员变量和成员方法
2）应用：修饰成员变量，提供对应的getxxx()/setxxx()方法

@例题：封装与private 的应用 ：学生类的重新定义

class Student{
private String name;
private int age;

public int getName(){
return name;
}
public int getAge(){
return age;
}
public void setName(String s){
name=s;
}
public void setAge(int i){
age=i;
}
}

9、this关键字
1） 所在类的对象引用
格式：this.本类变量名
局部变量隐藏成员变量
例如：

public void setAge(int age){
//age=age;
//错误，由于就近原则赋值失败，系统不能区分左边的是成员变量，右边是局部变量
this.age=age;//正确
}

2）图解