二维数组，类和对象

二维数组，类和对象

二维数组

构成：在一维数组的基础上进行了扩展，即一维数组的每一个元素也是一个一维数组，其实java中不存在二维数组的结构。

例如：

int school [][]= new int[5][];//开启最大维度的长度
school[0] =new int[5];//开启二维数组第一个最大维度的元素空间
school[1]=new int[10];//开启二维数组第二个最大维度的元素空间

//格式1：
数据类型[][]变量名=new 数据类型[m][n];
//m:行 二维数组中可以存储一维数组的个数
//n:列 一维数组的长度
//格式2:
数据类型[][]变量名=new数据类型[m][];
//m:二维数组中可以存储一维数组的个数，
//一维数组的长度由我们动态进行指定
  //格式3：
数据类型[][]变量名= new 数据类型[][]{{元素1，元素2，元素3，。。。元素n},{元素1，元素2，元素3，。。。元素n},{元素1，元素2，元素3，。。。元素n}};
//简化格式：
数据类型[][]变量名={{元素1，元素2，元素3，。。。元素n},{元素1，元素2，元素3，。。。元素n},{元素1，元素2，元素3，。。。元素n}};

  

二维数组的遍历

分析：1，遍历二维数组中存储的一维数组个数。for(int i=0,i<arr.length;j++){}

2,遍历二维数组中的每一个一维数组的元素

提取二维数组中的每一个一维数组：

3,会发现二维数组的遍历，外层循环控制二维数组的最大维度，内层循环控制

int[][]school={{1,2,3},{4,5},{6,7,8,9}};//定义一个二维数组
//遍历二维数组
for(int i=0;i<school.length;i++){//外层循环控制二维数组的最大维度
  for(int j=0,j<school[i].length;j++){//内层循环控制每一个一维数组的长度
    //提取二维数组的每一个一维数组的元素
    System.out.print(school[i][j]);
  }
}

面向对象

1，思想

2，面向过程和面向对象的区别

面向过程：上课的过程：起床—>>刷牙—>>洗脸—>>穿鞋—>>出门—>>打车—>>走进教室—>>上课

特点:具体的每一步我们都是参与者，关注的是解决问题的过程

面向对象：洗衣服，将衣服扔进了洗衣机，然后晾衣服，中间没有洗衣服的过程

特点：只关注最终的结果

3，面向对象的特点：

a，更符合人们思考问题的方式

b，把我们从执行者变为了调用者

c，将问题简化

4，举例：

把大象装入冰箱

设计行为更符合面向对象思想的思考：

分析：1，有哪些类 大象 冰箱 OOPDemo

2，每个类中有哪些行为，方法

大象类：吃草 走路

冰箱：开门，关门

OOPDemo:装大象的方法 main

3，类与类之间有怎样的关系

6,面向对象开发设计与特征

开发：不断创建对象，使用对象，修改对象

设计：管理和维护对象之间的关系。一个好的形象设计，可以实现程序的简化并且易于维护

特征：封装，继承，多态

7，类和对象

类：具有相同属性特征和行为特征的事物统称为类，只是一个抽象的概念

对象：是类的具体描述，万事万物皆对象；能看的得见摸得着的东西都是对象

类和对象的关系：对象是类的具体描述，类是对象的抽象

类是对象的数据类型

exemple：学生

属性：姓名，年龄，性别，体重，身高。。。。

行为：走路，吃饭，学习。。。。

属性：描述该事物具有的信息，对象特有的属性，每个对象的每个属性都具有特定的值

**行为：**该事物可以干什么，对象可以执行的操作

java中最基本的单位就是类，所以我们应该尝试使用类来描述事物

事物 类

属性 成员变量

行为 成员方法

exemple：学生----->>类

姓名，性别，年龄，身高，体重----->>成员变量

走路，吃饭，学习----->>成员方法
举例：手机类

/*类：手机
* 属性：品牌，价格
* 行为：打电话，发短信
* */
public class Phone {
    String brand;//手机品牌的成员变量
    int price;//手机价格的成员变量
    //打电话的成员方法
    public void call(){
        System.out.println("打电话");
    }
    //发短信的成员方法
    public void sentMessage(){
        System.out.println("发短信");

    }
}

创建手机类的对象

/*创建Phone类的对象*/
public class PhoneDemo {
    //主方法
    public static void main(String[] args) {
        Phone phone=new Phone();//创建phone类的对象
        System.out.println(phone.brand);//对对象的成员变量进行输出调用,输出null默认值
        System.out.println(phone.price);//对对象的成员变量进行输出调用,输出0默认值
        phone.brand="小米";//给成员变量赋值
        phone.price=1999;//给成员变量赋值
        System.out.println(phone.brand);//对对象的成员变量进行输出调用，小米
        System.out.println(phone.price);//对对象的成员变量进行输出调用，1999
        //使用成员方法
        phone.call();//打电话的方法
        phone.sentMessage();//发短信的方法
    }

}

8，类的使用

类的组成：属性和行为

属性：成员变量来体现

行为：成员方法来体现（无static ）

定义：访问修饰符 class 类名{

成员方法

构造方法(无参，有参) 默认存在一个隐形的无参结构

成员变量

}

9，类的调用：

1，实例化类 语法：类名 对象名=new 类名(); 比如：学生类 tom=new 学生类();

​ 类名 对象名=new类名([实参列表]);

2,调用类的属性：对象名.属性名 比如：tom.name

3,调用类中的方法：对象名.方法名([实参列表])；

构造方法：用于实例化类的对象的方法称为构造方法

分为：有参构造方法：实例化对象的同时为类中的成员属性进行赋值

​ 无参构造方法：实例化对象的时候对成员属性不进行赋值

语法格式：访问修饰符 方法名(){

​ }

​ 访问修饰符 方法名([行参列表]){

​ This.成员属性=行参

。。。。。。。}

/*this：代表当前类的对象
* 用途：1.用于区分成员变量和局部变量冲突问题，局部变量优先级高于成员变量
*      2.可以调用当前类的构造方法。
* 语法：this([参数列表]);不传参数在调用当前类的无参构造方法，相反调用参数列表相吻合的有参构造方法
* 注意：此条语句必须是方法体中的第一行语句。
* 3，可以调用成员属性：this.成员属性名
* 4，可以调用成员方法：this.成员方法名([参数列表])*/

注意：a，构造方法必须和其类名同名

b，没有返回值这一说法

c，如果在一个类中显示的定义有了构造方法，则隐形无参构造将不存在。此时建议将无参构造方法显示定义

d，每个类都有构造方法，如果没有显示为类构造方法，java编译器会为该类提供一个默认无参构造方法

e，在创建一个对象时，至少要调用一个构造方法。

f，一个类中可以有多个构造方法，它们之间构成了重载，即构造方法重载

9，在一个类中可以有以下变量

类变量：存在于类中，方法之外，声明时必须前面加static关键字；如：static int flag;随着类的加载而产生

	声明位置	内存中存储位置	生命周期	执行优先级	初始状态
成员变量	类中，方法体之外	堆内存中	随着对象产生而产生，随着对象消亡而消亡	成员变量和局部变量重名时采用就近原则	有默认初始化值
局部变量	方法体中或方法声明上	栈内存中	随着方法调用而产生，随着调用完毕而结束	成员变量和局部变量重名时采用就近原则	没有默认初始化值，必须手动初始化之后才可以调用