二维数组/类和对象/复杂度

二维数组

//二维数组其实就是一个特殊的一维数组
    int[][] array = {{1,2,3},{4,5,6}};
    int[][] array2 = new int[][]{{1,2,3},{4,5,6}};

    public static void main(String[] args) {
        //不规则二维数组
        int[][] array3 = new int[2][];//行必须有，列可以自己定义
        array3[0] = new int[3];
        array3[1] = new int[4];
        for (int i = 0; i <array3.length ; i++) {
            for (int j = 0; j <array3[i].length ; j++) {
                System.out.print(array3[i][j]+" ");
            }
            System.out.println();
        }
    }

类和对象

1. 面向过程 vs 面向对象的区别

以买手机为例
面向过程：全部过程自己完成
面向对象：秘书完成，自己使用

2. 面向对象编程的核心

（1）找对象【对象由类产生】
（2）创建对象
（3）使用对象

3. 类的成员：

（1）字段 属性 成员变量：类内部，方法外部
1. 普通成员变量
静态成员变量 类变量【当前成员变量被static所修饰】建议通过类名.静态成员变量去访问。静态的好处是不需要实例化对象。静态的成员变量，不存在于对象里面，在方法区。
2.在普通的成员方法当中，是否可以定义一个静态的成员变量？ 不可以
3.静态方法的内部，不可以调用普通的成员方法，为什么？
静态方法的本身调用是不依赖对象的，而普通成员方法的调用依赖对象
（2）方法

class Person{
    //1.字段-》属性  定义在方法外部，类的内部 -》成员变量
    public String name = "zyw";
    public int age = 18;
    //2.方法-》行为  -》成员方法
    public void eat(){
        System.out.println(name + "吃饭！");
    }
}

public static void main(String[] args) {
        Person person = new Person();//实例化对象
        System.out.println(person);
    }

4. 引用注意的问题

(1) Person person = null;//不指向任何对象
（2） Person person = new Person();
Person person1 = person;
代表person1这个引用，指向了person这个引用指向的对象
（3）引用变量一定在栈上吗？
不一定，在不在栈上取决于是不是局部变量
(4)一个引用 可以指向多个对象吗
不可以，只能保存一个对象的地址

5. 面向对象思想的特征

继承 封装 多态
（1）什么是封装？【安全，降低对类的使用成本】
语法层次上，字段和方法都被private修饰，此时就说 把这个字段或者方法进行了封装，被private修饰的字段和方法只能在当前类中使用，不能在类外使用。

      getName即为getter方法，表示获取这个成员的值
      setName即为setter方法，表示设置这个成员的值

构造方法

没有返回值，方法名称和类名一样；每一个类中都有一个构造方法，如果没有自己定义，则编译器会默认生成一个不带有参数的构造函数；支持重载，和普通重载规则一致。

this 表示当前对象的引用，而不是当前对象
1.调用属性，但是不能在静态中使用，因为静态不需要对象
2.调用方法
3.调用构造方法 this（）只能放在构造方法的第一行，保证不能同时构造两个对象

   this（name:"zyw");
   this（name:"zyw",age:"18"）;   ×  只能同时构造一个

代码块{}

代码块的出现是为了合适的时候处理数据

本地代码块：方法内部定义的代码块，基本不用
实例代码块：方法外部，类内部
静态代码块：static{}，只执行一次且最先执行
同步代码块…

执行顺序：静态代码块-》实例代码块-》构造方法
如果都是静态，和定义的顺序有关

toString

@override表示下面的toString方法重写了父类的方法

匿名对象

每次调用方法或变量都要重新创建（new）,所有只能在创建对象的时候使用，如果只用一次，可以考虑使用

public static void main(String[] args) {
        new Cat();//匿名对象，没有引用
    }

作业

1. 编写一个类Calculator，有两个属性num1,num2这两个数据的值，不能在定义的同时初始化，最后实现加减乘除四种运算

class Calculator{
    private int num1;
    private int num2;
    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }
public int add(){
        return this.num1+this.num2;
}
    public int sub(){
        return this.num1-this.num2;
    }
    public int mul(){
        return this.num1*this.num2;
    }
    public double dev(){
        return this.num1*1.0/this.num2;
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();//创建对象
        calculator.setNum1(10);
        calculator.setNum2(20);
        System.out.println(calculator.add());
        System.out.println(calculator.sub());
        System.out.println(calculator.mul());
        System.out.println(calculator.dev());
    }
}

2. 交换两个变量的值，要求改变实参的值

public static void swap(Myvalue mv1,Myvalue mv2) {
        int tmp = mv1.val;
        mv1.val= mv2.val;
        mv2.val = tmp;
    }

    public static void main(String[] args) {
        Myvalue myvalue1 = new Myvalue();
        myvalue1.val = 10;
        Myvalue myvalue2 = new Myvalue();
        myvalue2.val = 20;
        System.out.println(myvalue1.val+" "+myvalue2.val);
        swap(myvalue1,myvalue2);
        System.out.println(myvalue1.val+" "+myvalue2.val);
    }

复杂度

时间复杂度+空间复杂度
用来衡量一个算法的效率的

时间复杂度：

大O渐进法表示，去掉对结果影响不大的数
3N²+2N+10-》O(N²)
二分查找时间复杂度 O(log2^N)
递归的时间复杂度 = 递归的次数 * 每次递归之后的操作次数

空间复杂度

是一个算法在运行过程中临时占用存储空间大小的量度
递归的空间复杂度 = 递归的次数