形参和返回值
类名作形参
public void useCat(Cat c){
c.eat();
}
CatOperator co=new CatOperator();
Cat c=new Cat();
co.useCat(c)
类名作返回值
public Cat getCat(){
Cat c = new Cat();
return c;
}
CatOperator co=new CatOperator();
Cat c=co.getCat();
c.eat();
抽象类名作形参（要利用其子类）
public void useAnimal(Animal a){
a.eat();
}
AnimalOperator ao=new AnimalOperator();
Animal a=new Cat();
ao.useAnimal(a);
抽象类名作返回值（要利用其子类）
public Animal getAnimal(){
Animal a=new Cat();
return a;
}
AnimalOperator ao=new AnimalOperator();
Animal a=ao.getAnimal();
a.eat();
接口名作形参（要利用类）
public void useJumpping(Jumpping j){
j.jump();
}
JumppingOperator jo=new JumppingOperator();
Jumpping a=new Cat();
jo.useJumpping(j);
接口名作返回值（要利用类）
public Jumpping getJumpping(){
Jumpping j=new Cat();
return j;
}
JumppingOperator jo=new JumppingOperator();
Jumpping j=jo.getJumpping()
j.jump;
内部类
类中定义一个类
格式
public class 类名{
修饰符 class 类名{
}
}
eg: public class Outer{
private int num=10;
public void method(){
Inner i=new Inner();
i.show();
}
public class Inner{
public void show(){
System.out.println(num);
}
}
}
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类成员，必须创建对象
成员内部类
定义在类的成员位置
成员内部类，外界创建对象使用格式
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
eg:针对上面的例子
Outer.Inner oi = new Outer().new Inner();//Inner修饰符是private
Outer 0=new Outer();//Inner修饰符是private，通过在外部类编写访问方法来访问
o.method();
局部内部类
定义在类的方法里面，外界无法直接使用，要在方法内部创建对象并使用
局部内部类可以直接访问外部类成员，也可以访问方法内局部变量
public class Outer{
private int num = 10;
public void method(){
class Inner{
public void show(){
System.out.println(num);
}
}
Inner i = new Inner();
i.show();
}
}
测试
Outer o = new Outer();//间接调出Inner类里面的方法
o.method();
匿名内部类
局部内部类的一种特殊形式
本质是实现了一个继承了该类或者实现了该接口的子类匿名对象
格式
new 类名或接口名(){
重写方法;
};
eg:
public class Outer{
public void method(){
new Inner{
public void show(){
System.out.println("xxx");
}
}.show();//new里面的内容是一个对象，直接用.调方法
Inter i = new Inner02{
public void show(){
System.out.println("xxx");
}
};//new的是一个对象，所以可以直接赋值给一个接口i
i.show();//再用i调用方法
}
}
主函数
Outer o=new Outer();
o.method;
当方法需要一个类作为形参时，为了避免重复为接口或抽象类创建子类，来实现方法调用，可以创建1个临时的匿名对象作为替代
需要调用方法
Jumpping是1个接口
public void method(Jumpping j){
j.jump();
}
方法1：创建Cat类，接上jumpping接口，并且在其中重写jump()方法，
之后就可以利用类创建对象并调用方法
JumppingOperator jo=new JumppingOperator();
Jumpping j = new Cat();
jo.method(j)
方法2：使用匿名类，创建临时的对象替代
JumppingOperator jo=new JumppingOperator();
jo.method(new Jumpping(){
public void jump(){
System.out.println("xxxx");
}
});
常用API
帮助文档中，如果该类无构造方法，则看成员是否都是静态，是则通过类名就可直接调用
工具类设计思想
- 构造方法用private修饰：防止外界创建对象
- 成员用public static修饰：让用户使用类名来访问该方法
Math
public static int abs(int a)返回参数绝对值
public static double ceil(double a)返回大于等于参数的最小double值，等于1个整数
public static double floor(double a)返回小于或等于参数的最大double值，等于1个整数
public static int round(float a)四舍五入返回最接近参数的int
public static int max(int a,int b)返回两个int中较大值
public static int min(int a,int b)返回两个int中较小值
public static double pow(double a,double b)返回a的b次幂的值
public static double random()返回值为double的任意1个正值[0.0,1.0]
使用Math.xxx
System
public static void exit(int status)终止当前运行的java虚拟机，非0表示异常终止
public static long currentTimeMillis()返回当前时间(以毫秒为单位)，可以用其记录程序运行时间
使用System.xxx
Object
所有类直接或间接继承自该类，有构造方法public Object()
public String toString()方法底层意义为
输出文件地址+@+一串代码()(寻找方式为不断go to 每一层的方法代码)
建议所有Object子类重写此代码，可以alt+insert找到toString()快速重写
public boolean equals(Object obj)指示一些其他对象是否等于此
对用同一类创建的两个对象而言，无法直接比较，因此要重写equals方法
类中Alt+insert——>equals() and hashCode()——I>ntellij Default然后一直next到结束,删除多余的hashCode()重写方法
public boolean equals(Object o) {
//this ---- s1 o ---- s2
//比较两地址是否相同，相同直接返回true
if (this == o) return true;
//判断参数是否为null
//判断两个对象是否来自于同一类
if (o == null || getClass() != o.getClass()) return false;
//向下转型
Student student = (Student) o;
//比较年龄是否相同
if (age != student.age) return false;
//比较姓名是否相同
return name != null ? name.equals(student.name) : student.name == null;
}
Arrays
Arrays类包含用于数组操作的各种方法
public static String toString(int[] a)返回指定数组的内容的字符串表示形式
public static void sort(int[] a)按照数字顺序排序指定的数组
使用Arrays.xxx
冒泡排序
package com.arrayLearning;
public class ArrayDemo {
public static void main(String[] args) {
int[] arr={24,69,80,57,13};
System.out.println("排序前："+arrayToString(arr));
for (int x=0;x<arr.length-1;x++){
for(int i=0;i<arr.length-1-x;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
}
System.out.println("排序后："+arrayToString(arr));
}
public static String arrayToString(int[] arr){
StringBuilder sb=new StringBuilder();
sb.append("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
sb.append(arr[i]);
}else{
sb.append(arr[i]).append(",");
}
}
sb.append("]");
String s=sb.toString();
return s;
}
}
基本类型包装类
将基本数据类型封装成对象
优势：在对象中可定义更多的功能方法操作该数据
常用操作：基本数据类型<=>字符串转换
基本数据类型<——>包装类
byte<——>Byte
short<——>Short
int<——>Integer
long<——>Long
float<——>Float
double<——>Double
char<——>Charater
boolean<——>Boolean
Integer类的使用
public static Integer valueOf(int i)方法返回表示指定int值的Integer实例
eg:Integer i1=Integer.valueOf(100);
public static Integer valueOf(String s)方法返回表示指定值的Integer对象String
eg:Integer i1=Integer.valueOf("100");//字符串里的必须是数字
public String[] split(String regex)方法将字符串以regex字符为分割，形成字符串数组
eg:String s="97 27 46 38 50";
String[] strArray=s.split(" ");
int和String类型的相互转换
int——>String
int number=100;
方式1
String s1=" "+number;
方式2：
调用public static String valueOf(int i)方法
String类中方法，返回int参数的字符串表示形式
String s2=String.valueOf(number);
String——>int
String s="100";
方式1:String——>Integer——>int 调用public int intValue()方法
Integer i=Integer.valueOf(s);
int x=i.intValue();
方式2：
public static int parseInt(String s)方法
Integer类中方法，将字符串解析为int型
int y=Integer.parseInt(s)
自动装箱和自动拆箱
装箱：把基本数据类型转换为对应包装类类型eg:Integer i=Integer.valueOf(100);
自动装箱：eg:Integer i=100;还是调方法只是被省略
拆箱：把包装类类型转换为对应的基本数据类型
eg:i=i.intValue()+200//函数部分即为拆箱操作，之后加法是在装箱
自动装箱：eg:i+=200调方法部分被省略
ps.使用包装类类型，只要是对象，在使用前必须进行不为null的判断
Date日期类
public Date()分配一个Date对象，并初始化，它代表它被分配的时间，精确到毫秒
public Date(long date)分配一个Date对象，将其初始化为表示从标准基准时间起指定的毫秒数
public long getTime()获取的是日期对象从1970.1.1 0点到现在的毫秒值
public void setTime(long time)设置时间，给的是毫秒值
SimpleDateFormat类
用于日期格式化和解析 ； y年 M月 d日 H时 m分 s秒
- 格式化(Date到String)
public final String format(Date date)将日期格式化为日期/时间字符串 - 解析(String到Date)
public Date parse(String source)从给定字符串开始解析文本以生产日期 - 构造方法
public SimpleDateFormat()构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)构造一个SimpleDateFormat使用给定的模式和默认的日期格式
Date->String
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s=sdf.format(d);
String->Date
String ss="2021-01-21 15:40:34";
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd=sdf2.parse(ss);//此处会出现异常，直接抛出即可
Calendar类
某一时刻和一组日历字段之间的转换提供了一些方法
public int get(int field)返回给定日历字段的值eg:c.get(Calendar.YEAR)
public abstract void add(int field,int amount)根据日历规则，将指定的时间添加或减去给定的日历字段
public final void set(int year,int month,int date)设置当前日历年月日
获取任意1年2月份有多少天
Scanner sc=new Scanner(System.in);
System.out.println("请输入年份");
int year=sc.nextInt();
Calendar c=Calendar.getInstance();
c.set(year,2,1);//表示的是3月1日，月从0开始
c.add(Calendar.DATE,-1);//3月1日往回退1天就是2月的最后1天
int date=c.get(Calendar.DATE);
System.out.println(year+"年的2月份有"+date+"天");
