Java

一、面向对象

　　面向对象主要针对面向过程。

　　Java是完全面对对象编程的语言，对于Java来说，一切皆是对象，把现实世界中的对象抽象地体现在编程中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的，对象之间通过相互作用传递信息，实现程序开发。

　　概念：面向对象的程序核心由对象组成，所谓对象具是真实世界中的实体，对象与实体一一对应，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念，每个对象都包含这对用户公开的特定功能和隐藏的实现部分，程序中很多对象来自于JDL标准库，而更多的类需要我们自己定义。

　　对象的特点：

　　　　　　　　　　对象具有属性和行为；

　　　　　　　　　　对象具有变化的状态；

　　　　　　　　　　对象具有唯一性；

　　　　　　　　　　对象都是某个类别的实例。

　　面向对象的特点：

　　　　　　　　　　以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能；

　　　　　　　　　　先有数据结构再有算法；

　　　　　　　　　　面向对象可以将复杂的业务逻辑简单化，增强代码复用性；

　　　　　　　　　　面向对象具有封装、继承、多态、抽象四个特征。

二、类和对象的关系

    类：

          对某类事物的普遍一致性特征、功能的抽象、描述与封装，是构造对象的模板或蓝图，是具有相同属性和方法的一组对象的集合，用Java编写的代码都会在某些类的内部。类之间的关系主要有依赖、聚合、继承等。

　　类中的成员：

　　　　　　　　属性

　　　　　　　　方法

　　　　　　　　构造方法

　　　　　　　　程序块

　对象：

　　　使用new关键字或反射技术创建的某个类的实例。同一个类的所有对象都具有相似的数据和行为，但是每个对象都保存着自己独特的状态，对象状态会随着程序的运行而发生改变，需要注意状态变化必须通过调用方法来改变。

　　对象是类的个体，类是抽象的概念，对象是具体的产物，程序中由类产生对象。

　　堆内存：保存的是对象的具体信息。

　　栈内存：保存的是一块堆内存的地址，即通过地址找到堆内存然后找到对象内容。

三、调用方法参数及返回值问题：

  返回值：方法在执行完毕后给调用它的环境的数据

   返回值类型：事先约定好的返回值的数据类型，如无返回值则必须给出返回值类型void

　return语句终止方法的运行并制定要返回的数据；

　　　　注意： 基本数据类型传递的是该数据本身，引用数据类型传递的是对对象的引用，而不是对象本身

    public void changeArray(int[] x){
        System.out.println("方法执行开始:"+x[0]);//1
        x[0] = 10;//修改数组x的第一个位置元素
        System.out.println("方法执行最终:"+x[0]);//10
　　　　
　　　　//不需要返回值
    }

    //每一个类中不是必须包含主方法的
    //主方法不属于任何一个类--主方法属于虚拟机
    public static void main(String[] args){
        //0.加载类模板的过程
        Test t = new Test();
        int[] a = new int[]{1,2,3};
        t.changeArray(a);
        //方法存在堆内存的对象空间里 方法执行在栈内存中的临时空间
        //调用方法时将a的值传递给了x    int[] x = a;  传递过来的就是一个 引用
        System.out.println("方法执行完毕,main方法中a数组的第一个值:"+a[0]);//10
}

   1.形参 ：用来接收调用该方法时传递的参数，只有在被调用的时候才分配内存空间，一旦调用结束就会释放内存空间。因此仅仅在方法内有效。

　　　　　　也可理解为方法被调用时，用于接受外界输入的数据

 public void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
        System.out.println("a:" + a + " b:" + b);
    }//这里边的a,b就是形参，temp是一个局部变量，方法结束，在栈空间中就会被销毁

　2.实参：传递给被调用方法的值，预先创建并赋予确定值。

　　　　　　也可理解为调用方法时，外界传给方法的数据

//调用上面的swap
swap(1,2);
//其中1和2就是实际的参数，就叫实参 

   形参可以理解为是方法执行时的临时变量空间   x；

　实参可以理解为是方法调用时传递进去的参数   a；

　方法调用时会将实参的内容传递给形参；

　如果内容是基本类型，则传递的是值， 则形参改变  实参不变；

　如果内容是应用类型，则传递的是引用， 形参改变，实参跟着改变。

public class Test {
    public int changeNum(int x){
        System.out.println("方法执行开始:"+x);//1
        x = 10;//修改传递进来的值
        System.out.println("方法执行最终:"+x);//10
        return x ;//基本数据类型 需要返回值 将x临时的变量空间内的值(值 引用)返回出来
    }
    public static void main(String[] args){
        Test t = new Test();//堆内存中开辟空间
        int a = 1;
        a = t.changeNum(a);//需要一个int的条件  int x = a;

　　　　　System.out.println("a = "+ a);

    }
}

程序运行结果：

　　　　方法执行开始:1
　　　　方法执行最终:10
　　　　a = 10

   　　　　图解：

 小任务：

　1.　设计一个方法，用来交换两个数组元素

　2.　设计一个方法，用来交换一个数组（头尾互换）

　3.　设计一个方法，用来寻找数组中的极限值

　4.　设计一个方法，用来寻找给定的元素是否在数组内存在

　5.　设计一个方法，用来给数组元素排序

 　　方法一：

public class Test {
    //设计一个方法  用来交换两个数组的元素
    //  方法本身是否需要参数及返回值   需要参数 提供两个数组  返回值 不要
    public void changeTwoArray(int[] a, int[] b) {//2.交换数组中的元素
        //方式一  将两个数组内的元素对应位置互换
        for (int i = 0; i < a.length; i++) {//每一次找到一个数组中的元素 跟另一个数组对应位置
            int x = a[i];
            a[i] = b[i];
            b[i] = x;
        }
        //方式一的设计问题在于
        // 用循环的方式挨个交换数组内的元素 性能比较慢
        //交换的时候需要保证两个数组的长度是一致的
　　　　　　//不需要返回值
    }
        public static void main (String[]args){
            //创建一个Demo对象
            Test d = new Test();
            //用来交换两个数组元素 a{1,2,3,4}  b{5,6,7,8}
            //1.先有两个数组
            int[] x = {1, 2, 3, 4};
            int[] y = {5, 6, 7, 8};
            //2.调用demo中的changeTwoArray方法
              d.changeTwoArray(x, y);
         
            //3.验证一下看一看
            for (int v : x) {
                System.out.println(v);
            }
            System.out.println("-----------");
            for (int v : y) {
                System.out.println(v);
            }
        }

    }

　　

方法二：

public class Test {
    //设计一个方法  用来交换两个数组的元素
    //  方法本身是否需要参数及返回值   需要参数 提供两个数组  返回值 不要
    public int[][] changeTwoArray(int[] a,int[] b){
        //方式二  将两个数组的地址引用直接互换
        int[] temp = a;
        a = b;
        b = temp;
        int[][] result = {a,b};
        return result;
    }

    public static void main(String[] args){
        //创建一个Demo对象
        Test d = new Test();
        //用来交换两个数组元素 a{1,2,3,4}  b{5,6,7,8}
        //1.先有两个数组
        int[] x = {1,2,3,4};
        int[] y = {5,6,7,8};
        //2.调用demo中的changeTwoArray方法
        int[][] value = d.changeTwoArray(x,y);
        x = value[0];
        y = value[1];
        //3.验证一下看一看
        for(int v:x){
            System.out.println(v);
        }
        System.out.println("-----------");
        for(int v:y){
            System.out.println(v);
        }
    }

}