java进阶笔记Day(三)

类/接口作为参数和返回值
把类作为参数和返回值

• 把类作为参数: 调用方法时传递就是该类的对象(地址)

• 把类作为返回值类型：调用方法时实际返回的是该类的对象(地址)
  把抽象类作为参数和返回值

• 把抽象类作为参数: 调用方法时传递就是该类的子类对象(地址)

• 把抽象类作为返回值类型：调用方法时实际返回的是该类子类的对象(地址)
  把接口作为参数和返回值

• 把接口作为参数: 调用方法时传递就是该接口的实现类对象(地址)

• 把接口作为返回值类型：调用方法时实际返回的是该接口的实现类对象(地址)
  内部类
  在一个类的内部定义另外一个类，这个类就是内部类。根据在类中的位置不同分为下面的几种
  成员内部类
  局部内部类
  匿名内部类
  成员内部类 【重点】

public class Outer{
int num=10;
//成员内部类
public class Inner{
int num=20;
public void method(){
int num=30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(Outer.this.num);//10
}
}

public  void outMethod(){
    Inner in=new Inner();
    in.method();
} 

}

public class Demo1 {
public static void main(String[] args) {
// Outer out=new Outer();
// out.outMethod();

    //创建Outer内部的Inner对象
    //格式:外部类.内部类 变量名=new 外部类().new 内部类();
    Outer.Inner in=new Outer().new Inner(); 
    in.method();
}

}
局部内部类（了解）

public class Outer{
public void method(){
//局部变量 : 只能在方法中使用
int num=10;
System.out.println(“Inner…show”);

    //局部内部类: 只能在方法中使用
    class Inner{
        public void inMethod(){
            System.out.println("Inner..show");
        }
    }
    Inner in=new Inner();
    in.inMethod();
}

}
匿名内部类（重点）
匿名内部类其实就是一个没有名字的局部内部类（特殊的格式），它有些使用的前提。

• 有一个抽象类/接口
• 格式：
  new 抽象类/接口(){
  复写抽象方法
  }
• 【本质：匿名内部类本质上是抽象类或者接口的子类对象】
  public class Demo3 {
  public static void main(String[] args) {
  //Animal d接收的事Animal的子类对象
  Animal d = new Animal(){
  @Override
  public void eat() {
  System.out.println(“狗吃骨头”);
  }
  };
  d.eat();
  d.eat();
  d.eat();
  ​
  System.out.println("-----------");
  //匿名内部类直接调用方法
  new Animal(){
  @Override
  public void eat() {
  System.out.println(“猫吃鱼”);
  }
  }.eat();
  }
  }
  匿名内部类在开发中的使用（经常作为方法的参数传递）

//学生类
public abstract class Student{
public abstract void study();
}
//Java学生
public class JavaStudent extends Student{
public void study(){
System.out.println(“Java学生学习Java课程”);
}
}
//老师类
public class Teacher{
//老师教学生
public void teach(Student stu){
stu.study();
}
}
//测试类
public class Demo4{
public static void main(String[] args){
Teahcer t=new Teahcer();
//老师教Java学生学习
JavaStudent stu=new JavaStudent();
t.teach(stu);

//老师教UI学生学习
t.teach(new Student(){
  public void study(){
    System.out.println("UI学生在学习UI课程");
  }
}); 

}
}
API常用的类
Math类【重点】
Math类给我们提供了一个常用的数据 运行相关方法

public static final double PI=3.14159265358979323846;
圆周率是一个常量
public static int abs(int n)
求一个数的绝对值
public static int round(double d)
对一个数进行四舍五入
public static double ceil(double d)
向上取整 3.14–>4.0
public static double floor(double d)
向下取整 3.14–>3.0
public static double pow(double a,double b)
求一个数的几次幂
public static double sqrt(double a)
获取一个数的平方根
public static double random()
获取一个[0.0,1.0)的随机数
public static int max(int a, int b)
求两个数的最大值
public static int min(int a, int b)
求两个数的最小值
System类【重点】

public static arrayCopy(Object src,int srcPos,Object dest,int destPos,int length)
复制数组，参数解释如下：
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

public static long currentTimeMillis()
获取当前的系统时间(毫秒值) 距离1970年1月1日的毫秒值

public static void exit(int status)
退出JVM,参数一般给0就可以了。

public static void gc()
告诉垃圾回收器回收垃圾。
Object类【重点】
Object表示所有类的父类，任何一个子类都可以使用Object类的方法

public String toString()
把一个对象转换为字符串（字符串的格式： ”全类名@哈希码值“ ）
建议子类复写此方法，返回自己想要的字符串(快捷键：alt+insert–>toString())
【注意：
1)打印一个对象是地址，就说明没有复写toString方法
2)任何一个对象不是地址，就说明复写了toString方法
】

public boolean equals(Object obj)
判断两个对象是否“相等”(本质上是比较对象的地址)
建议子类复写equals方法，按照属性值进行判断两个对象是否相等
快捷键：alt+insert–>hashCode() And equals()

public int hashCode() 【了解】
获取一个对象的哈希码值(可以当做地址值来理解)
【每一个对象的hashCode一般是不同的，如果hashCode方法被复写了hashCode值就可能相同】

Arrays类【重点】
Arrays表示数组的工具类

public static void sort(int[] a)
对数组中的元素进行排序
public String toString(int[] array)
把数组转换为固定格式的字符串 如: [1,2,3,4,5]
public static int binarySearch(int[] a, int key)
采用二分查找法，查找一个数组中指定元素的索引，如果找不到就返回一个负数。
注意：必须先对数组进行排序，而且元素不能重复。

int[] array={10,20,8,9,4,6,7,1,2};
//对数组进行排序
Arrays.sort(array);
​
//遍历数组中的元素
String str = Arrays.toString(array);
System.out.println(str); //[1, 2, 4, 6, 7, 8, 9, 10, 20]
​
//查询18元素出现的索引
int i = Arrays.binarySearch(array, 18);
System.out.println(i);
冒泡排序【了解】
冒泡排序是将两个相邻的元素进行比较，大的往后放。

public class Demo09 {
public static void main(String[] args) {
int[] array={101,23,48,5,6,2,6,7,93,4};
sort(array);
//Arrays.sort(array);
​
//打印数组中的元素
String s = Arrays.toString(array);
System.out.println(s);
}

//对数组进行排序（冒泡排序）
public static void sort(int[] array) {
    //外层循环比较的轮数
    for (int i = 0; i < array.length-1; i++) {
        //内层循环控制每一轮比较的次数
        for(int j=0;j<array.length-1-i;j++){
            //相邻的两个元素做比较
            if(array[j]>array[j+1]){
                int temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
}

}