参数传递与内部类

参数传递

1、类名作为形参和返回值

1、类名作为方法的形参

方法的形参是类名，其实需要的是该类的对象

实际传递的是该对象的【地址值】

2、类名作为方法的返回值

方法的返回值是类名，其实返回的是该类的对象

实际传递的，也是该对象的【地址值】

2、抽象类作为形参和返回值

抽象类作为形参和返回值

  方法的形参是抽象类名，其实需要的是该抽象类的子类对象
  方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

package com.itfenghua01;

public abstract class Animal {
    public abstract void eat();
}
-------------------------------
    package com.itfenghua01;

public class AnimalOprete {
    public void useAnimal(Animal a){
        a.eat();
    }
    public  Animal getAnimal(){
        Animal a = new Dog();//返回的是抽象类的子类对象
        return a;//a=new Dog()
    }
}
-------------------------------
 package com.itfenghua01;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----------------------------
 package com.itfenghua01;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}
----------------------------
    package com.itfenghua01;

public class Demo {
    public static void main(String[] args) {
        AnimalOprete ao = new AnimalOprete();
        Animal a = new Dog();//传递是该抽象类的子类对象
        ao.useAnimal(a);//狗吃肉
        Animal ao2 = ao.getAnimal();
        ao2.eat();//狗吃肉
        Animal b = new Cat();
        ao.useAnimal(b);//猫吃鱼

    }
}

3、接口名作为形参和返回值

接口作为形参和返回值

 方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回的是该接口的实现类对象

package cn.itfenghua01;

public interface Swimming {
    public void Swim();
}
---------------------------------
package cn.itfenghua01;

public class SwimmingOperate {
    public void useSwimming(Swimming s){
           s.Swim();
    }
    public Swimming getSwim(){
        Swimming s = new Palyer();
        return s;//返回值是该接口的实现对象
    }
}
---------------------------------
package cn.itfenghua01;

public class Palyer implements Swimming {
    @Override
    public void Swim() {
        System.out.println("运动员学游泳");
    }
}
--------------------------------
package cn.itfenghua01;

public class Demo {
    public static void main(String[] args) {
        SwimmingOperate so = new SwimmingOperate();
        Swimming s = new Palyer();
        so.useSwimming(s);//传递的参数是接口的实现对象
        Swimming s2 = so.getSwim();//返回值是该接口的实现对象
    }
}

4、参数与返回值

1.对象传参

1.以普通类作为参数（形参）
可以传递的实参：
本类对象
该类的子类对象
2.以抽象类作为参数
可以传递的实参：
该抽象类的子类对象
3.以接口作为参数：
可以传递的实参：
该接口的实现类对象

2.对象类型作为方法的返回值类型

1.以普通类作为返回值类型：
可以返回值类型：
本类对象
该类的子类对象
2.以抽象类作为返回值类型
可以返回值类型：
该抽象类的子类对象
匿名内部类（实际还是该抽象类的子类对象）
3.以接口作为返回值类型：
可以返回值类型：
该接口的实现类对象
匿名内部类

3、内部类

1、内部类概念

类中的类称之为内部类，
包含内部类的类，称之为外部类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

2、内部类的访问特点

​ 内部类可以直接访问外部类的成员，包括私有

​ 外部类要访问内部类的成员，必须创建对象

注： 同一个java文件中只有一个public class,可以有多个class

4、成员内部类

成员内部类的定义位置

    在类中方法，跟成员变量是一个位置

外界创建成员内部类格式

1）格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

​ 举例：Outer.Inner oi = new Outer().new Inner();

2）在外部类中声明一个方法，此方法中对内部进行实例化

成员内部类的推荐使用方案

 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用

5、局部内部类

1、局部内部类定义位置

​ 在方法内的内部类。

2、局部内部类方式方式

​ 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

​ 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

package com.itfenghua02;


public class Outer {
    private int num = 34;

    public void method() {
        int num2 = 12;
        class Inner {
            public void show() {
                //成员变量和局部变量都可以使用
                System.out.println(num + ",我是局部内部类");
                System.out.println(num2);
            }
        }
        //通过创建对象调用
        Inner i = new Inner();
        i.show();
    }
}
---------------------------------
package com.itfenghua02;

public class Demo {
    int num = 20;

    public class Simple {
        public void show() {
            System.out.println(num + ",我是成员内部类");
        }
    }
   //成员内部类通过方法创建对象调用
    public void Test() {
        Simple s = new Simple();
        s.show();
    }
}
-----------------------------------
package com.itfenghua02;

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
        //34，我是局部内部类
        //12
        Demo d = new Demo();
        d.Test();//20,我是成员内部类

    }
}

6、匿名内部类

1匿名内部类的前提

​ 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

2匿名内部类的格式

​ 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

3匿名内部类的本质

​ 本质：是一个继承了该类或者实现了该接口的子类匿名对象

4匿名内部类的细节

​ 匿名内部类可以通过多态的形式接受

5一般用于：
1.抽象类的没有名称的子类实例化
new 抽象类（）{
重写抽象类中所有的抽象方法；
}；
2.接口的没有名称的实现类的实例化
new 接口(){
重写接口中所有的方法；
}
注：匿名内部类实质是没有名称的子类或者是实现类的实例化

package com.itfenghua04;

public abstract class Animal {
    public abstract void jumping();
}
----------------------------------
package com.itfenghua04;

public class AnimalOprate {
    public void method(Animal a){
       a.jumping();
    }
}
-------------------------------------
package com.itfenghua04;

public class Demo {
    public static void main(String[] args) {
        AnimalOprate ao = new AnimalOprate();
        ao.method(new Animal() {
            @Override
            public void jumping() {

            }
        });
    }
}

7、常用的类

1、 Math类

1.Math类是数学操作类
包含：
1.常量
2.静态成员方法
注：使用Math类无需创建对象
2.常用方法：
ceil()向上取整
floor()向下取整
round()四舍五入
max()取最大值
min()取最小值
random()生成0.0到1.0随机数（左闭右开即包含0.0不包含1.0）[)）

2 、System类

1.System类也称之为系统操作类
public final class System
是个最终的类，不可被继承

 private System() {}
构造方法是私有的，所以不能实例化
成员都是static修饰的，所以无需创建对象直接调用

2.常用的方法：
exit()终止JVM运行
currentTimeMillis()获取系统当前时间距离1970年1月1日的毫秒值

package com.itfenghua05;

public class Demo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println((end-start)+"毫秒");
    }
}

3、 Object类

1.Object类是类层次结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。
2.Object类只用一个无参构造方法
3.常用方法：
toString()：输出是对象地址
equals():只比较对象地址
4.重写toString()
将对象的内容输出
5.重写equals()
不仅比较对象地址，同时还比较对象的内容

4 、冒泡排序

冒泡排序的原理：
对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数 据按要求完成排序。
每一次比较完毕，下一次的比较就会少一个数据参与（提取当前比较的最大值）
冒泡排序执行的次数：
如果有n个数据进行排序，总共需要比较n-1次

5 、Arrays类

1.Arrays类是数组工具类
2.常用的方法：
sort():将数据排序
toString()：将数组转换成字符串

package com.itfenghua05;

import java.util.Arrays;

public class GetArrray {
    public static void main(String[] args) {
        int[] arr = {345,12,23,456,56,48};

        System.out.println(Arrays.toString(arr));//[345, 12, 23, 456, 56, 48]
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[12, 23, 48, 56, 345, 456]
    }
}