面向对象1

java面向对象的3条主线

1.java类及类的成员、属性、方法、构造器、代码块、内部类
2.面向对象三大特征：封装性、继承性、多态性
3.其他关键字：this、super、static、final、abstract、interface、package、import等

面向对象(OOP)和面向过程（POP）

OOP：强调具备功能的对象，以类/对象为最小单位，考虑谁做
POP：强调功能行为，以函数为最小单位，考虑怎么做
eg:人把大象塞入冰箱

面向对象2要素：

类：对一类事物的描述，是抽象的、概念上的定义
对象：实际存在的该类事物的每个个体，也称为实例
创建类的对象=类的实例化=实例化类

对象的内存解析

堆（heap）：唯一目的存放对象实例；对象的非static属性也存放在堆中
栈（stack）：通常所说的是虚拟机栈，用于存放局部变量等。8种基本数据类，对象引用（reference类型，不等同于对象本身，是对象在堆内存的首地址）。方法执行完后，自动释放
方法区（Method Area）：存储类的加载信息、常量池、静态变量、即时编译器编译后的代码等

内存解析说明：引用类型的变量，只能存储两类值：null或地址值（含变量的类型）

匿名对象：只能使用一次

new Phone().sendMessage();//方式一
PhoneMail mail= new PhoneMail();
mail.show(new Phone());//方式二：开发中常用

变量

实例（无static）变量：有默认初始化值
局部变量：没有默认初始化值，即局部变量必须赋值；特别的，形参在调用时，才去赋值
内存中的位置：实例变量加载到堆内存中；局部变量加载到栈空间

return

1.作用范围：使用在方法中
2.作用：（1）void返回时结束方法，使用“return ；”（2）针对有返回值类型的方法，使用“return 数据”方法返回需要的数据
3.注意：return关键字后不能声明执行语句

方法

1.重载

方法同名，参数个数或类型或顺序不同即可（两同一不同：同一个类、相同方法名；参数列表不同（类型或个数或顺序））

2.可变形参的方法（String... str） （jdk5.0新特性）

形参不同的方法之间也构成重载（String str和String... str）；必须声明在末尾（int a,String... str）；最多只能声明一个可变形参

    void find(String str){
        
    }
    void find(String... str){
        
    }
//String... str和String[] str作用等同，只能存在一个
    void find(String[] str){
        
    }
//String... str和int a,String... str同时存在时，在int a,String... str中，顺序不能颠倒
    void find(int a,String... str){
        
    }

3.方法参数的值传递机制

变量的赋值：变量是基本数据类型，保存的是数据值；变量是引用数据类型，保存的是数据地址值
形参的传递机制：值传递
（1）形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
（2）值传递机制
若参数是基本数据类型，此时实参付给形参的是真是存储的数据值；
若参数是引用数据类型，此时实参付给形参的是变量所保存的数据地制值

//基本数据类型；传递存储的数据值
    static void swap(int i,int j){
        int temp = i;
        j = temp;
        temp = j;
    }
    //引用数据类型，此时arr代表数组对象引用地址值，i，j表示引用的位置；传递地址值
    static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp ;
    }
    public static void main(String[] args) {        
        int[] arr = new int[]{23,-5,26,-59,-42,5,86,99};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1- i; j++) {
                if(arr[j] > arr[j + 1]){
//                   swap(arr,j,j+1);//冒泡结果正确
                    swap(j,j+1);//只是在方法内部冒泡，执行完方法后释放，仍然是原数组顺序
                }
            }
        }
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.print(arr[i]+"\t");
        }   

举例：

    static class Value{
        int i = 15;
    }
    static void first(){
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v,i);
        System.out.println(v.i);
    }
    static void second(Value v,int i ){
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i+"...."+i);
    }
    public static void main(String[] args) {    
        Array01 arr = new Array01();
        arr.first();
//结果 15....0   20

运行图.png

例题1：（*****考察重写，并不是参数传递）

    public static void main(String[] args) {    
        int a = 10;
        int b = 20;
        method(a,b);//需要在method方法调用之后，仅打印出a=100,b=200,写出method的代码
        System.out.println("a="+a);
        System.out.println("b="+b);

方法一：System.exit(0);表示终止当前jvm的执行

private static void method(int a, int b) {
        a  = a* 10;
        b = b* 10;
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.exit(0);//直接在该方法执行完后退出
    }

方法二：重写println方法

private static void method(int a, int b) {
        PrintStream ps = new PrintStream(System.out){
        @Override
        public void println(String str){
            if("a=10".equals(str)){
                str = "a= 100";             
            }else if("b=20".equals(str)){
                str = "b= 200";             
            }
            super.println(str);
        }
        };
        System.setOut(ps);

    }

例题2：定义一个int型数组：int[] arr = new int[]{12,3,3,34,56,77,432};让数组的每个位置上的值去除以首位置的元素，得到的结果作为该位置上的新值。遍历新的数组。

int[] arr = new int[]{12,3,3,34,56,77,432};
        int temp = arr[0];
//错误写法，arr[0]在第一次运算后，值已经改变
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] / arr[0];
        }
        //方法一：倒序相除，原因是arr[0]值到最后一次值才会改变
        for (int i = arr.length - 1; i >= 0;i--) {
            arr[i] = arr[i] / arr[0];
        }
//方法二：定义一个arr[0]空间,确保其值不变
//      for (int i = 0; i < arr.length; i++) {          
//              arr[i] = arr[i] / temp;     
//      }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }

例题3：

        int[] arr1 = new int[3];
        System.out.println(arr1);//[I@15db9742
        char[] arr2 = new char[3];
        System.out.println(arr2);//口口口
        String[] arr3 = new String[3];
        System.out.println(arr3);//[Ljava.lang.String;@6d06d69c
        
        int[] arr4 = new int[]{1,2};
        System.out.println(arr4);//[I@7852e922
        char[] arr5 = new char[]{'d'};
        System.out.println(arr5);//d
        String[] arr6 = new String[]{"a"};
        System.out.println(arr6);//[Ljava.lang.String;@4e25154f

4.递归recurison：一个方法体内调用自身

static int getSum(int n){
        if(n == 1){
            return 1;
        }else{
            return n + getSum(n-1);
        }
    }
    public static void main(String[] args) {
        Array01 test = new Array01();
        System.out.println(test.getSum(100));//5050