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；