值传递: 调用一个方法的时候，传递给方法的参数 ，实际上传递变量所存储的值。

需求1：定义一个函数交换两个基本类型变量的值。

需求2： 定义一个函数交换数组中两个 元素的位置。

代码演示：

import java.util.*;
class Person2{

    int x =10;
}


class Demo5
{
    public static void main(String[] args)
    {
      /*
      int a = 3;
      int b = 5;
      changeValue(a,b);
      System.out.println("交换之后的值：a = "+a +" b="+b);

      int[] arr = {23,10,9};
      changeArr(arr,1,2);
      System.out.println("数的元素："+ Arrays.toString(arr));// 9 ,10
         */
        Person2 p = new Person2();
        changeObj(p,20);
        System.out.println("x = "+ p.x);
    }

    public static void changeObj(Person2 p ,int x){
        p.x = x;
    }




    //需求2： 定义一个函数交换数组中两个 元素的位置。
    public  static void changeArr(int[] arr , int index1,  int  index2){
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;

    }



    //需求1：定义一个函数交换两个基本类型变量的值。
    public static void changeValue(int a , int b){
        int temp = a;
        a = b;
        b = temp;
        System.out.println("方法内部交换的值：a = "+a +" b="+b);
    }

}
运行结果：

 值交换的分析：

1，基本类型的值交换：

 2，引用类型的值交换：

一个类最多只能有一个直接的父类。但是有多个间接的父类。

java是单继承。

代码演示：

class Ye{

    String name;

}

class Fu1 extends Ye{

}

//
class  Zi1 extends Fu1{

}

class Demo10
{
    public static void main(String[] args)
    {
        // System.out.println("Hello World!");
        Zi1 zi1 =new Zi1();
        zi1.name = "好人";
    }
}
结果：

接口：

接口：拓展功能的。 usb接口.。。

接口的定义格式：

interface 接口名{

}

接口要注意的事项 ：
1. 接口是一个特殊的类。
2. 接口的成员变量默认的修饰符为： public static final 。那么也就是说接口中的成员变量都是常量。
3. 接口中 的方法都是抽象的方法，默认的修饰符为： public abstract。
4. 接口不能创建对象。
5. 接口是没有构造方法的。
6. 接口是给类去实现使用的，非抽象类实现一个接口的时候，必须要把接口中所有方法全部实现。

实现接口的格式：

class 类名 implements 接口名{

}

代码演示：

interface A{

    //成员变量
    public static final int i=10;

    //成员函数
    public void print();
}


class Demo33 implements A{ // Demo7就实现了A接口

    public static void main(String[] args)
    {
        Demo33 d = new Demo33();
        d.print();
    }

    //实现接口中的方法
    public void print(){
        System.out.println("这个是接口中的print方法...");
    }

}
运行结果：

接口的作用：
1. 程序的解耦。 （低耦合）
2. 定义约束规范。
3. 拓展功能。

代码演示：

//普通的铅笔类
class Pencil{

    String name;

    public Pencil(String name){
        this.name = name;
    }

    public void write(){
        System.out.println(name+"沙沙的写...");
    }
}


//橡皮接口
interface Eraser{

    public void remove();
}


//带橡皮的铅笔
class PencilWithEraser extends Pencil implements Eraser {

    public PencilWithEraser(String name){
        super(name);
    }


    public void remove(){
        System.out.println("涂改,涂改....");
    }
}


class Demo33
{
    public static void main(String[] args)
    {
        //System.out.println("Hello World!");

        PencilWithEraser p = new PencilWithEraser("2B铅笔");
        p.write();
        p.remove();

    }
}
运行结果：

　接口需求分析：

 接口定义约束规范分析：

类与接口之间关系： 实现关系。

类与接口要注意的事项：
1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的 方法。
3. 一个类可以实现多个接口 。

疑问： java为什么不支持多继承，而支持了多实现呢？
class A{

public void print(){
System.out.println("AAAAAA");
}
}

class B{

public void print(){
System.out.println("BBBBBB");
}
}

class C extends A ,B{

}

new C().print();

接口与接口之间关系： 继承关系。

接口与接口之间要注意事项：
1. 一个接口是可以继承多个接口的。

代码演示：

interface A{

    public void print();
}


interface C{

    public void getArea();
}


interface B extends A,C{ // B接口继承A接口

    public void test();
}



class Demo34 implements B{

    public static void main(String[] args)
    {
        Demo34 d = new Demo34();
        d.print();

    }

    public void getArea(){}


    public void test(){}


    public void print(){
        System.out.println("这个是A接口的print方法...");
    }
}
运行结果：