API(Java笔记)

已于 2022-01-19 20:56:24 修改
阅读量398 收藏
点赞数 3
分类专栏： 学习笔记 文章标签： java 开发语言 后端
于 2022-01-19 20:52:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54274889/article/details/121641540
版权
API(Java)
  • API(Application Programming Interface)应用程序编程接口
  • java语言中实际提供的类和接口
  • API文档:对java中提供的类和接口中的功能进行说明的文档
基本类型包装类

  • Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面

    向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设

    计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和

    基本数据类型对应的类统称为包装类.

  • 包装类（如：Integer，Double等）这些类封装了一个相应的基本数据

    类型数值，并为其提供了一系列操作方法。
    在这里插入图片描述

对于包装类来说，这些类的用途主要包含两种：

  • 作为和基本数据类型对应的类类型存在。

  • 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操

    作方法。

包装类常用属性方法以及装箱和拆箱(Auto-boxing/unboxing)：
  • 以Integer类为例：
public class DemoInteger {
    public int value ;
    public DemoInteger(int value){this.value=value;}//构造方法
}
public class Demo{
    public static void main(String[] args) {
        DemoInteger di = new DemoInteger(10);
        Integer integer = new Integer(10);//把基本类型包装到对象中
        Integer integer1 = new Integer("10");/*在内部先把String类型的"10"先转换为基本类型的10，然后再包装到对象中*/
        int i= integer.intValue();//把对象中的基本类型取出
        int i1 = integer1.intValue();


        System.out.println(integer.equals(integer1));
        System.out.println(Integer.MAX_VALUE);//最大值2147483647
        System.out.println(Integer.MIN_VALUE);//最小值-2147483648
        System.out.println(Integer.SIZE);//位数32
        System.out.println(Integer.BYTES);//字节数4

        System.out.println(Integer.toBinaryString(integer.intValue()));//转二进制
        System.out.println(Integer.toOctalString(integer1.intValue()));//转八进制
        System.out.println(Integer.toHexString(demoInteger.value));//转十六进制


        Integer integer2 = Integer.valueOf(10);//将基本类型转换为引用类型
        Integer integer3 = Integer.valueOf("10");

        int i2 = Integer.parseInt("-129");//将String类型转换为int类型

        Integer integer4 = i2;//自动装箱，实质还是在内部自动调用valueOf()
        Integer integer5 = -129;
        Integer integer6 = 127;
        Integer integer7 = 127;
        System.out.println(integer4==integer5);/*false,大于等于128和小于-128的数会new Integer()*/
        System.out.println(integer6.equals(integer7));/*true,小于128大于等于-128的数会直接从缓冲区拿出，缓冲区中创建了256个Integer类型的对象*/

        int i3 = integer4;//自动拆箱，在内部自动调用intValue()
        System.out.println(i3);
    }
}

运行结果：
在这里插入图片描述

Object类：
  • 是java中所有类的基类(超类 (祖宗类)) 所有类直接间接继承Object 为实现多态性
public class Car {
    private String name;
    private float price;

    public Car(String name, float price) {//车类有参构造方法
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {//重写Object类中的toString方法
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
        /*
           native修饰的方法称为本地方法(有些方法java是不实现的,直接调用本地操作系统中的方法)
           输出一个对象时,默认回调用类中toString(), 我们的类中如果没有定义toString(),找父类中的toString()
           Object类中的toString(){
               getClass().getName()+"@" hashCode() 转换成16进制的字符串
           }
         */

    @Override
    public boolean equals(Object obj) {//重写equals方法
        Car car = (Car)obj;//向下转型，将Object类型转为它的子类Car类型
        return this.name== car.name&&this.price==car.price;//对内容进行比较
    }

}
public class TestCar {
    public static void main(String[] args) {
        Car car1 = new Car("奔驰",600000f);
        Car car2 = new Car("奔驰",600000f);
        Car car3 = new Car("宝马",500000f);
        System.out.println(car1+"\n"+car2+"\n"+car3);
        /*
        输出对象时会默认调用类中的toString方法，若类中没有就会调用父类
        中的toString方法，这里若没有重写toString()就会调用Object类中的
        toString();Object类时java中所有类默认的基类（祖宗类，超类），
        所有类直接或间接继承Object类
         */
        System.out.println(car1==car2);
        /*
          "==" 用于基本类型的比较  比较的值是否相等
          "==" 用于引用类型比较  比较的是引用地址(对象地址)是否相等
          这里是引用类型的比较，和--Object类中的equals方法--实现相同，比较的是他们的地
          址，而他们是不同的对象，地址一定不同，所以输出false
        */
        System.out.println(car1.equals(car2));
        //在Car类中重写了equals方法，比较类中内容是否相同，输出true
        System.out.println(car3.equals(car1));//false
    }
}

运行结果：
在这里插入图片描述

Arrays类
  • 用于操作数组工具类，里面定义了常见操作数组的静态方法。
  • equals方法
import java.util.Arrays;
/*
声明：public static boolean equals(type[]a,type[]a2)
参数的类型可以是基本数据类型和引用类型的任意一种类型。
内容相等则返回true，否则返回false。例
*/
public class EqualsDemo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        int[] b = {1,2,3,4,5};
        Arrays.equals(a, b);//比较数组中的内容是否相等
        System.out.println(Arrays.equals(a, b));//true
    }
}
  • sort方法(排序)及copyOf方法(数组复制)
import java.util.Arrays;
/*
将指定的类型（除boolean以外的任意原生数据类型）数组所有元素（或指定范 围内的元素）按数字升序进行排序。
*/
public class Sort {
    public static void main(String[] args) {
        int [] a = {5,3,4,2,1,9,16};
        int [] b = Arrays.copyOf(a,10);//传入原数组，返回一个新数组，还可以设置新数组的长度
        ystem.out.println(Arrays.toString(b));
        Arrays.sort(a,0,3);/*对某个区间排序 sort(type[] a,开始位置(包含结束),结束位置(不包含结束位置));*/
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//默认从0-length-1  底层使用的是快速排序的排序方法
        System.out.println(Arrays.toString(a));
    }
}

运行结果：
在这里插入图片描述

  • object型数组会根据元素的自然顺序，对指定对象数组进行升序排序。
  • 自定义对象排序
    • 自定义类实现Comparable接口
    • 重写compareTo方法
public class Acount implements Comparable/*<Acount>*/{//自定义类实现Comparable(可比较)接口
    private int id;
    private String acount;
    private String password;
    public Acount(int id,String acount,String password){
        this.acount=acount;
        this.id=id;
        this.password=password;
    }

    @Override
    public String toString() {
        return "Acount{" +
                "id=" + id +
                ", acount='" + acount + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
    /*
       这里重写了compareTo方法，它为我们的引用
       类型提供一个自定义排序规则,方法会在Arrays
       类中的sort()方法底层调用结果是用来判断大小  小于0  等于0  大于0
     */
    @Override
    public int compareTo(Object o/*Acount acount*/) {
        Acount a = (Acount) o;//可以强制向下转型，也可以利用泛型
        //return this.id-a.id;
        return this.acount.compareTo(a.acount);/*若是比较String类型的数据
        就会，调用底层compareTo（）方法，把字符串转化为字符数组，再去统计比较各字符串中字符编码和的大小*/
    }
}

import java.util.Arrays;

public class TestAcount {
    public static void main(String[] args) {
        Acount acount1 = new Acount(1, "123456", "111111");
        Acount acount2 = new Acount(2, "123457", "222222");
        Acount acount3 = new Acount(3, "123458", "333333");
        Acount acount4 = new Acount(4, "123459", "444444");
        Acount acount5 = new Acount(5, "123460", "555555");
        Acount[] acounts = new Acount[]{acount1, acount4, acount5, acount2, acount3};
        Arrays.sort(acounts);//按照 Acount类中的某个成员变量进行排序，这里按acount排序
        for(int i=0;i<acounts.length;i++){
            System.out.println(acounts[i]);
        }

    }
}

运行结果：
在这里插入图片描述

  • binarySearch -使用二分搜索算法搜索指定数组

    import java.util.Arrays;
/*
声明： 
      public static int binarySearch(type[] a, type key) 默认在0-length-1范围里查找key
      public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
      从fromIndex-toIndex范围查找key，不包含toIndex
*/
public class BinarySearch {
    public static void main(String[] args) {

        int [] a = {8,2,7,4,5,6,3,1,9};
      Arrays.sort(a);//二分查找前提是数据是有序的，所以这里先排序
      System.out.println(Arrays.toString(a));
      System.out.println(Arrays.binarySearch(a, 10));
      //返回负数表示没有找到，若key在数组里，应该是在返回负数的绝对值处
      System.out.println(Arrays.binarySearch(a, 0,6,3));
    }
}

    运行结果：
    在这里插入图片描述

  • toString() 方法（只是重写了Object中的toString方法）

    • 声明：public static String toString(type[] a)

    • 描述：返回指定数组内容的字符串表示形式。

    • 基本数组，字符串表示形式由数组的元素列表组成，括在[]中，相邻元素用“, ”(逗号加空格)分隔。

String类
  • String类概述

​ 字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字

​ 符串都是String类的实例.

  • String类有两种创建方式

    1. String s = "abc";
/*
   先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找 有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中 的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.
   */

    2. String s = new String("abc");
//用构造方法直接创建新对象，值存储在 堆内存 的对象中，且是独一无二的。

  • String类的构造方法

    public String()//创建一个只有""的空字符串，并不是null
public String(String str)
public String(byte[] bytes) //将byte型数组的内容转换为String类型，常用来解码
    String s0 = "你好啊";
    byte[] b = s0.getBytes("UTF-8");//编码，一个汉字对应三个byte型数字
    String s02 = new String(b,"UTF-8");//解码
public String(char[] value)//将字符型组拼接成一个String类字符串

  • String类中的判断功能(boolean类方法)

boolean equals(Object obj)//判断与另一个字符串对象是否相等
boolean equalsIgnoreCase(String str)//与equals不同的是此方法判断时不区分大小写 
boolean contains(String str)//判断字符串中是否包含另一个字符串
boolean isEmpty() //判断字符串是否为空
boolean startsWith(String prefix) //测试此字符串是否以指定的前缀开头。
boolean endsWith(String suffix)//测试字符串是否以指定的后缀结束。
  • String类中的获取功能
int length() //获取字符串长度
char charAt(int index) //获取指定索引的字符
int indexOf(String str) //获取str在字符串第一次出现的索引
int indexOf(String str,int fromIndex)//从索引fromIndex开始获取字符串str在字符串中第一次出现的索引
String substring(int start) //截取start之后的字符串包括start处的字符
String substring(int start,int end)//截取start-end之间的字符串，不包括end
  • String类中的转换功能
byte[] getBytes() 
char[] toCharArray() //将字符串转换成Char数组
static String valueOf(char[] chs)
/*静态方法，将chs数组中的字符拼接成字符串返回，底层还是new Stirng(char [] )*/
String toLowerCase()// 将字符串转换为小写
String toUpperCase() //将字符串转换为大写
String concat(String str) //方法用于将指定的字符串连接到另一字符串上。
Stirng[] split(分割符);/*方法根据匹配给定的正则表达式来拆分字符串。注意 . 、 $、 | 和 * 等转义字符，必须得加 \\ 。*/
  • String类中的替换功能
String replace(char old,char new);//将字符串中所有的字符old替换为字符new
String replace(String old,String new);//将字符串中所有的字符串old替换为字符串new
replaceAll(String regex, String replacement);//使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串。
replaceFirst(String regex, String replacement);//使用给定的参数 replacement 替换字符串第一个匹配给定的正则表达式的子字符串。
  • String中的trim()方法：删除字符串首尾的空格返回
StringBuffer类
  • StringBuffer类概述
    • 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题。
    • 线程安全的可变字符序列
  • StringBuffer类的构造方法
/*
    当向StringBuffer中添加内容时,是将内容添加到底层的数组中,数组没有被final修饰,当数组装满时,会创建一个新的数组,将新数组地址给底层数组,StringBuffer对象是不会改变的.
*/
StringBuffer stringBuffer = new StringBuffer();//底层char数组默认长度为16
StringBuffer stringBuffer1 = new StringBuffer(30);//底层char数组长度设为30
StringBuffer stringBuffer2 = new StringBuffer("abcd");//~20
stringBuffer.append("abcd1111");//此时底层数组长度不变
stringBuffer.append("efgh11111");/*此时底层数组长度变为42，底层数组对象虽然变了，但是StringBuffer对象却不会变*/
  • 添加功能
public StringBuffer append(String str)//向末尾追加内容
public StringBuffer insert(int offset,String str)//向指定的位置插入字符串
  • 删除功能
public StringBuffer deleteCharAt(int index)//删除指定索引的字符
public StringBuffer delete(int start,int end)//删除指定区间的内容 包含开始,不包含结束
  • 替换功能
public StringBuffer replace(int start,int end,String str)//把指定区间的子字符串替换为字符串str
  • 反转功能
public StringBuffer reverse()//将字符串反转 "abc->cba"
  • 截取功能
public String substring(int start)//截取start之后的字符串包括start处的字符返回
public String substring(int start,int end)//截取start-end之间的字符串，不包括end返回
    //返回的是String类型的，但本身没变
StringBuilder
  • StringBuilder类功能和StringBuffer功能完全一致, 但StringBuffer是线程安全的
String类StringBuffer类StringBuilder区别
  • String：是字符常量,适用于少量的字符串操作的情况
  • StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
  • StringBuffer：适用多线程下在字符缓冲2
Math类
  • java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。
  • 静态方法
Math.PI//圆周率 （3.141592~）
abs(); //绝对值
sqrt(); //平方根
pow(double a, double b); //a的b次幂
max(double a, double b);//返回大的值
min(double a, double b);//返回小的值
random(); //返回 0.0 到 1.0 的随机数
long round(double a); //double型的数据a转换为long型（四舍五入）
Random类
  • 此类用于产生随机数
  • 构造方法
Random random = new Random();
  • 成员方法
public int nextInt();
public int nextInt(4);//随机产生一个0--<4的数
System类
  • System 类包含一些有用的类字段和方法。它不能被实例化。
  • 成员方法
public static void exit(0);//推出虚拟机 
public static long currentTimeMillis();//获取当前时间的毫秒数，自1970年1月1日0时起的毫秒数.
Date类
  • 使用Date类代表当前系统时间
Date d = new Date(); //创建一个日期对象,里面包含了程序运行时的那一刻的时间,提供方法方便操作
Date d = new Date(long d);//两种构造方法

System.out.println(date.getTime());//1637485760505
System.out.println(date.getYear()+1900);// 称为过期方法,不建议使用,有新方法代替
System.out.println(date.getMonth()+1);//0,1,2,3,4,...,获取月数

System.out.println(date.getHours());//获得指定时间小时数 几点（0-23）
System.out.println(date.getMinutes());//获得指定时间的分钟数 （几点）几分
System.out.println(date.getSeconds());//获得指定时间的秒数 （几点几分）几秒
Calendar类
  • Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
/*例：
    Calendar.getInstance(); 获得是一个子类对象GregorianCalendar 公历*/
    Calendar c1 = Calendar.getInstance();//用getInstance方法创建
    c1.get(Calendar.YEAR);//获取 本年的年份，从1970年开始
//或
    Calendar c2 = new GregorianCalendar();//用他的子类GregorianCalender实现
    System.out.println(c2.get(Calendar.DAY_OF_WEEK));//获取 本周的第几天，从星期天开始（包括星期天）
    System.out.println(c2.get(Calendar.DAY_OF_YEAR));//获取 本年年的第几天
    /* Calendar.DAY_OF_MONTH本年第几月 
       Calendar.WEEK_OF_YEAR本年第几周
       Calendar.WEEK_OF_MONTH本月第几周
       Calendar.DAY_OF_WEEK本周第几天
       ...
    */
    Date d = c2.getTime();//getTime()方法返回的是一个Date对象
    Date data = new Date(c2.getTimeInMillis());//获取 从1970年到c2对象创建所经过时间的long类型时间值，包装在date对象中
    System.out.println(data);//输出时间，按Date中toString方法的格式输出
SimpleDateFormat 日期格式化类

  • 构造方法：

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//括号里的格式不唯一，但也有一定的限制
//yyyy代表年份 MM代表月 dd代表日 E代表星期几 HH mm ss分别表示时 分 秒 SSS表示毫秒

  • 日期转字符串

  • Date d1 = new Date();//先创建一个日期对象
String s = sdf.format(d1);//按照上面yyyy-MM-dd的格式把d1这个日期转为字符串输出
System.out.println(s);//输出d1对象创建时刻的时间

  • 字符串转日期

  • String birthday = "2001-12-13";
SimpleDateFormat mysdf = new SimpleDateFormat("yyyy-MM-dd");//日期格式必须和指定格式一致
try{//防止birthday的规则错误
    Date d2 = mysdf.parse(birthday);//把字符串birthday解析为Date类型
    System.out.println(d2);//Thu Dec 13 00:00:00 CST 2001
}catch(ParseException e){
    e.printStackTrace();
}
BigInteger类
  • 我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。
  • BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。
  • BigInteger类位于java.math包中
  • 构造方法
//BigInteger(String val) /BigInteger(byte[] val) ...
BigInteger b = new BigInteger("922337203685477580711111111111111111111111111111");
  • 基本运算方法
//add()加 subtract()减 multiply()乘 divide()除
BigInteger b1 = new BigInteger("11111111111111111111111111111111111111111111111");
BigInteger b2 = new BigInteger("22222222222222222222222222222222222222222222222");
System.out.println(b1.add(b2));//33333333333333333333333333333333333333333333333
BigDecimal类
  • 在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去 一定的精确度。
  • 根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可 能不精确。只能无限接近于那个值.
double a = 1.0-0.9;
double b = 0.8-0.7;
System.out.println(a==b);//false
  • 在现实生活中，特别是金融项目，我们必须做到计算十分精确So Java在java.math包中提供的API BigDecimal
  • 构造方法
//BigDecimal(String val)
BigDecimal bigDecimal = new BigDecimal("11.9");
  • 基本运算方法
//add() subtract() multiply() divide()
BigDecimal b1 = new BigDecimal("12");
BigDecimal b2 = new BigDecimal("11.9");

System.out.println(b1.subtract(b2));//减法 得0.1

BigDecimal b3 = new BigDecimal("10");
BigDecimal b4 = new BigDecimal("3");

//                             精度         舍入模式：向正无限大方向舍入
System.out.println(b3.divide(b4,3,BigDecimal.ROUND_CEILING));//除法 得3.334
打字不快
关注
专栏目录
Java常用的API笔记，pdf格式
05-10
java常用的API笔记，李兴华老师写的，适合java初学者的学习，谢谢！
韩顺平java笔记完整版.zip（无笔记，只是代码）
10-10
通过韩顺平老师的Java笔记完整版代码，学习者可以深入理解上述知识点，并通过实践加深对Java编程的理解和掌握。这些代码示例涵盖了广泛的Java应用领域，对于初学者和进阶开发者都是宝贵的资源。
Java精选笔记_Java API
:)一位靓仔偶然路过的博客
07-03 423
String类 String类的初始化 String是一个特殊的对象，一旦被初始化，就不会被改变 1、使用字符串常量直接初始化一个String对象 String  s1="abc"; //s1是一个类类型变量，“abc”是一个对象。 2、使用String的构造方法初始化字符串对象 String  s2=new String("abc"); s1和s2的区别： s1
java学习笔记-API基本使用1
qq_44653420的博客
11-17 395
java学习笔记-API基本使用1 API： 应用程序接口 简单的来说 就是java帮助我们已经写好的一些方法 我们直接拿过来用就可以 1.Math 包含基本数学运算 所有的成员都是静态的 直接通过类名进行调用 Math.abs(); //返回参数的绝对值 Math.ceil();//向上取整 Math.floor();//向下取整 Math.round();//四舍五入 Math.max(10,20);//返回较大值 Math.min();//返回最小值 Math.pow(a,b);//
JAVA API笔记
supperpop的博客
03-26 242
System.in 标准输出设备，即键盘 Scanner sc=new Scanner(System.in) 扫描输入信息 sc.nextInt() 读取一个扫描的整数（建议sc.next()读取字符串） 不能直接读取1个字符（char），可以先以字符串读取，再调用String.charAt(0)读取第0个字符 System.currentTimeMillis() 计算当前...
Java API笔记
GuoWuZhu的博客
09-27 347
Java API:Application Programming Interface,应用程序编程接口。 String类 java.lang 声明：public final class String 最终类：字符串不变，它们的值在创建后不能被更改 构造方法： public String();创建无参构造 public String(String original);传一个String类型的值创建对...
Java基础 学习笔记 Markdownr版
06-27
5. Java 8新特性：18Java8新特性.md中会涵盖Lambda表达式、函数式接口、Stream API、日期和时间API等Java 8的重要更新，这些新特性极大地简化了代码，增强了Java的表达力。 6. 反射与动态代理：17反射与动态代理.md...
java API核心笔记
05-04
java常用API，程序员必看内容，错过不要后悔，业界大佬编写
狂神说Java笔记资料
04-14
《狂神说Java笔记资料》是一份全面涵盖Java开发基础知识的文档集，旨在帮助学习者系统地掌握Java编程。这份笔记包含多个章节，每个章节都深入讲解了一个特定的主题，覆盖了从初学者到进阶开发者必备的知识点。 1. *...
java全套笔记 来自狂神说java笔录.zip
12-28
【Java笔记内容概览】 1. **基础语法**：涵盖变量、数据类型、运算符、流程控制（条件语句、循环语句）、数组、字符串等基础知识。 2. **面向对象**：讲解类、对象、封装、继承、多态等核心概念，以及构造函数、...
java_Api
03-17
NULL 博文链接：https://zlemo1984.iteye.com/blog/505193
Java API学习笔记
m0_48936146的博客
04-12 952
一、字符串类 1.1 String类的初始化，几个常见的构造方法 String() //创建一个内容为空的字符串 String(String value) //根据指定的字符串内容创建对象 String(char[] value) //根据指定的字符数组创建对象 String(byte[] bytes) //根据指定的字节数组创建对象 String测试案例 public class test8 { public static void main(String[] args)throw.
Java API学习笔记（一）
勿忘初心
07-31 4018
1. 不要重复初始化变量默认情况下，调用类的构造函数时，java会把变量初始化成确定的值，所有的对象被设置成null，整数变量设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键字创建一个对象时，构造函数链中的所有构造函数都会被自动调用。这里有个注意，给成员变量设置初始值但需要调用其他方法的时候，最好放在一个方法
Java API
Gnimlew的博客
08-12 4227
API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。......
JAVA_API笔记[完结]
zidieq的博客
10-19 367
API(Application Programming Interface，应用程序接口)的学习笔记。主要是常见API的简单索引，不会有太详细的说明。
java API 个人学习笔记
Marllxr的博客
05-25 190
1. API api是一些预先定义好的函数 我们无需理解起内部机制和细节，就可以使用其功能 api也作为规则，面向接口开发 2. 3. Object 每个类都使用Object作为超类（顶级父类），一个类没有明确指定父类，默认继承Object类。 常用方法： toString()：默认返回对象地址值，重写后打印对象类型+属性 hashCode()：返回对应对象的哈希码值 equals()：默认实现==比较两个对象地址值 4.String String底层是char[] ...
java重要api个人笔记
zhenxi2735768804的博客
09-03 684
1、Math类 ①Math.PI // 获取π的值； ②Math.sin(30)// 获取正弦的值 ③Math.cos(30)//获取余弦的值 ④Math.sqrt(16)//求平方根 ⑤Math.pow(a,b)// a的b次幂 ⑥Math.abs(-1)//取绝对值
JAVA笔记 - API基础
ECNU第一菜鸡的博客
05-30 378
文章目录1. toString 和 equals 方法1. toString2. equals3. java.lang package2. Scanner类3. Random类4. ArrayList类泛型常用的ArrayList方法5. String类创建String的四种方法字符串的常量池空指针异常常用API6. Arrays常用API7. Math常用API8. 日期和时间类常用方法Date...
JAVA--API
Mikowoo007的博客
07-06 410
JAVA8 API官网 翻墙查看
Java API学习笔记：常用方法与Eclipse快捷键
"Java常用API及其使用方法" 在Java编程中，API（Application Programming Interface）是一组预先定义的函数、类、接口和常量，它们为开发者提供了构建软件或应用程序的工具。Java API是Java语言的核心组成部分，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值