JAVA基础课总结五



一、二维数组

 

A:二维数组格式

int[][] arr = new int[3][2]; 

   int[][] arr = new int[3][];

   int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

B:二维数组的遍历

  arr.length   获取二维数组的长度，也是一维数组的个数

  arr[i].length  获取每个一维数组的长度

 arr[x][y]获取二维数组的元素

二维数组遍历

 

* 外循环控制的是二维数组的长度，其实就是一维数组的个数。

* 内循环控制的是一维数组的长度。

 

int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

        for (int i = 0;i < arr.length ;i++ ) { //获取到每个二维数组中的一维数组

for (int j = 0;j < arr[i].length ;j++ ) { //获取每个一维数组中的元素

System.out.print(arr[i][j] + " ");

}

System.out.println();

}

二、参数传递(理解内存图)

基本类型：形式参数的改变对实际参数没有影响。

引用类型：形式参数的改变直接影响实际参数。

理解：归根结底 是因为 基本类型是存在于栈内存中， 某个方法即使是改变了自己的栈内存的这个基本类型，那么等他调用结束了之后 方法本身就会消失 那么不影响原来的main方法中的值

   而引用类型就不一样了 因为引用类型是存在于堆内存中 我们是通过栈内存里存储的引用类型的地址值来改变引用类型的，在某个方法内通过地址值改变了堆内存中的引用类型的话 即使是这个方法消失了堆内存中的引用类型已经改变了 所以说形式参数的改变会影响实际参数

代码：

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

 

int[] arr = {1,2,3,4,5};

change(arr);

//{1,4,3,8,5}

System.out.println(arr[1]);//4

}

 

public static void change(int a,int b)

{

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

//return;

}

 

public static void change(int[] arr) //{1,2,3,4,5} -- {1,4,3,8,5}

{

for(int x=0; x<arr.length; x++)

{

//如何元素的值是偶数，那么，就把值变为以前的2倍。

if(arr[x]%2==0)

{

arr[x]*=2;

}

}

}

Java中是值传递，基本数据类型传递值，引用数据类型传递地址值，而地址值也是值

注意：基本数据类型当形参，需赋值

      引用数据类型当形参，给的是地址值，需要创建对象

三、面向对象

 

(1)面向对象：是基于面向过程的一种思想。

面向过程：以函数为基础，关注实现过程。

面向对象：以对象为基础，将功能封装进对象，强调具备了功能的对象。

       面向对象是基于面向过程的

(2)面向对象的思想特点：

A:是一种更符合人们思考习惯的思想。

B:把复杂的事情简单化了。

C:把我们从执行者变成了指挥者。

 

(3)事物是如何体现的呢?

A:属性 有哪些特征

B:行为 有哪些功能

(4)类与对象的关系：

把事物转换成类：

A:成员变量

就是事物的属性。定义在类中，方法外。

      

        成员变量的一个初始化过程

1：首先默认初始化

引用类型 null

Byte short int long  0

              Boolean  false

              Float double  0.0

char  空字符 ‘\u0000’

2：显示初始化 

成员变量在定义这个类的时候就给值了

 

3：调用过程中赋值

把刚才初始化成的值替换掉

B:成员方法

就是事物的行为

 

类：是相关的属性和行为的集合。是一个抽象的概念。

对象：是某种事物的具体存在，具体的表现形式。

（5）:面向对象开发

 就是不断的创建对象，使用对象，指挥对象做事情。

（6）:面向对象设计

 其实就是在管理和维护对象之间的关系。

（7）:面向对象特征

封装(encapsulation)

 继承(inheritance)

   多态(polymorphism)

(8)创建对象

格式：类名 对象名 = new 类名();

  调用成员

      对象名.变量名

      对象名.方法名(...)

注意：Car c =new Car();              c是对象的引用，记录的是地址值

如果c = null;          则c.run();会出现空指针异常，不能找到原来的对象

！空指针异常发生在引用数据类型，不会发生在基本数据类型，引用数据类型存在多个对象指向一个引用

(9）成员变量和局部变量的区别

A:在类中的位置不同

成员变量：在类中方法外

 局部变量：在方法定义中或者方法声明上

 B:在内存中的位置不同

 成员变量：在堆内存(成员变量属于对象,对象进堆内存)

局部变量：在栈内存(局部变量属于方法,方法进栈内存)

 C:生命周期不同

 成员变量：随着对象的创建而存在，随着对象的消失而消失

 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

 D:初始化值不同

 成员变量：有默认初始化值

 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

 注意事项：

 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

（10）方法的形式参数是引用类型时，需要创建对象调用

        如：public void print(Student s){}//print(new Student());

四、匿名对象

        是没有名字的对象。

 

应用场景：

A:当对对象方法仅进行一次调用的时，调用完毕就是垃圾

B:匿名对象可以作为实际参数进行传递

class Student

{

public void show()

{

System.out.println("student -- show");

}

}

class Test

{

//引用类型作为形式参数

public void print(Student s)

{

s.show();

}

 

public void print(int a)

{

System.out.println(a);

}

}

 

class NiMingTest 

{

public static void main(String[] args) 

{

Student s = new Student();

s.show();

//匿名对象的使用

new Student().show();

                   //匿名对象作为参数传递

Test t = new Test();

t.print(new Student());

}

}

 

五、封装

（1）概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

 

     封装好处

提高了代码的复用性

     提高安全性。

   封装原则

   把属性隐藏，提供公共方法对其访问。

 

（2）private关键字特点

 a:是一个权限修饰符

 b:可以修饰成员变量和成员方法

 c:被其修饰的成员只能在本类中被访问

     d :private修饰构造方法后不可以通过创建对象调用本类，如果是静态可以类名调用

封装和private的应用：

 A:把成员变量用private修饰

 B:提供对应的getXxx()和setXxx()方法

 private仅仅是封装的一种体现形式,不能说封装就是私有，比如类也是一个方法的封装等

六、this关键字: 代表当前方法（因为只能在方法中使用）所属的对象的引用。

 解决：局部变量隐藏成员变量的问题

注意：成员位置（方法外面 类里面）定义了一个变量 int num =10；

局部（方法内）变量里面还可以接着定义一个 int num =20；

但是 局部的局部（if 或者 for 或者while里面）就不能再定义                                                                                                         

举例：

 

public void show(){

int num = 20;

System.out.println(num);

if(true){

int num = 30;

System.out.println(num);

}

}

这样报错  局部有个 int num = 20 了 ，局部的局部又有了个 int num = 30；