day05 【常用API,引用类型小结】

反馈和复习

a.一个类,什么时候不能被继承(final),什么时候不能创建对象(抽象类,私有化构造方法),一个变量什么时候只能赋值一次(final)
b.老师少讲点,太多记不住(讲解的速度慢点)
Object类
toString: 默认返回包名.类名@地址值,重写之后返回对象的内容
equals: 默认比较两个对象的地址值,重写之后比较对象的内容
Date类:
public Date(); 当前时间
public Date(long millis);距离基准时间millis毫秒后的那个时间
DateFormat类:
public SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
格式化: public String format(Date d);
解析: public Date parse(String time);
Calendar类:
获取:Calendar cc = Calendar.getInstance();
方法:
public int get(int field);
public void add(int field,int value);
public void set(int field,int value);
Math类:
Math的方法都是静态的
public static double abs(double d);
public static double ceil(double d);
public static double floor(double d);
public static long round(double d);
public static double pow(double d,double d);
System类:
System类的方法也是静态,并且不能创建对象(System的构造方法私有化了)
System.exit(0); 退出JVM
System.currentTimeMillis(); 获取当前时间的毫秒值
System.arrayCopy(源数组,开始索引,目标数组,开始索引,复制的元素个数);

今日内容

BigInteger 大整数计算 【理解】
BigDecimal 高精度计算 【理解】
Arrays 工具类(方法都是静态的)
【重点】
包装类(八种基本类型对应的引用类型)
【重点】
String类的常用方法(基础班学了一些,但是远远不够) 【重点】
复习(类,抽象类,接口,多态)【难点】

第一章 BigInteger类【理解】

1.1 BigInteger的介绍

用于大整数计算(理论整数的位数是不受限制的)

1.2 BigInteger的构造方法

public BigInteger(String num); //创建一个大整数 

1.3 BigInteger的成员方法

BigInteger不能直接使用+-*/进行计算,而是用通过方法进行计算
public BigInteger add(BigInteger value); 求和
public BigInteger subtract(BigInteger value); 求差
public BigInteger multiply(BigInteger value); 求积
public BigInteger divide(BigInteger value); 求商
public class TestBigInteger {
public static void main(String[] args) {
//1.创建一个BigInteger
BigInteger b1 = new BigInteger("99999999999999999");
//2.计算
//求和
BigInteger add = b1.add(new BigInteger("1111111111111111"));
System.out.println(add);
//求差
BigInteger subtract = b1.subtract(new BigInteger("22222222222222222"));
System.out.println(subtract);
//求积
BigInteger multiply = b1.multiply(new BigInteger("33333333"));
System.out.println(multiply);
//求商,如果除不尽,那么不要小数部分
b1 = new BigInteger("10");
BigInteger divide = b1.divide(new BigInteger("3"));
System.out.println(divide);
}
}

第二章 BigDecimal类【理解】

2.1 使用基本类型做浮点运算的精度是有问题的

public class TestBigDecimal01 {
public static void main(String[] args) {
System.out.println(0.09 + 0.01); // 0.1
System.out.println(1.0 - 0.32);
// 0.68
System.out.println(1.015 * 100); // 101.5
System.out.println(1.301 / 100); // 0.01301
}
}
发现: 计算机在计算小数时总是可能存在精确的情况

2.2 BigDecimal的介绍

做高精度的浮点数运算

2.3 BigDecimal的构造方法

public BigDecimal(double d);
public BigDecimal(String s); 【推荐】

2.4 BigDecimal的成员方法

BigDecimal不能直接使用+-*/进行计算,而是用通过方法进行计算
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算(能除尽)
public BigDecimal divide(BigDecimal value,int 保留位数,RoundingMode.HALP_UP) 除法运算(不能除尽)
public class TestBigDecimal02 {
public static void main(String[] args) {
//1.创建一个BigDecimal
BigDecimal b1 = new BigDecimal("9.99999999999");
//2.计算
//加法
BigDecimal add = b1.add(new BigDecimal("1.11111111111111"));
System.out.println(add);
//减法
BigDecimal subtract = b1.subtract(new BigDecimal("2.222222222222222"));
System.out.println(subtract);
//求积
BigDecimal multiply = b1.multiply(new BigDecimal("3.33333"));
System.out.println(multiply);
//求商,注意,如果除不尽,会抛出异常
b1 = new BigDecimal("1.1");
//
BigDecimal divide = b1.divide(new BigDecimal("0.3"));
//
System.out.println(divide);
//如果除不尽,我们可以使用divide的一个重载方法
//BigDecimal divide(BigDecimal divisor, int scale, int roundingMode):
//
除数
保留几位小数
取舍模式
BigDecimal divide = b1.divide(new BigDecimal("0.3"), 5, RoundingMode.HALF_UP);
System.out.println(divide);
}
}
如果是基本类型除法,能否进行指定小数位数的保留,可以的,使用System.out.printf(查看API)

第三章 Arrays类【重点】

3.1 Arrays类的介绍

Arrays是专门操作数组的工具类(方法都是静态的)

3.2 Arrays类的常用方法

public static void sort(int[] a); 对数组中的元素进行从小到大的排序
public static String toString(int[] a); 将一个数组的元素拼成一个大的字符串返回
public class TestArrays {
public static void main(String[] args) {
//1.sort 排序方法
int[] arr = {4,5,3,6,7,8,1,2,9};
Arrays.sort(arr);
//2.输出
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//3.toString 将一个数组的所有元素拼成一个大的字符串返回
String arrStr = Arrays.toString(arr);
System.out.println(arrStr);
}
}
扩展一下:
sort方法对于数值类型数组排序时,按照数值的从小到大进行排序
sort方法对于char类型数组排序时,按照字符的码值从小到大进行排序
sort方法对于String类型数组排序时,首先比较首字母的码值,
如果相等再比较次字母的码值,依次类推,按照从小到到进行排序

第四章 包装类【重点】

4.1 包装类的介绍

包装类就是基本类型对应的引用类型,全称叫基本数据类型的包装类(简称包装类)
八大基本类型每种都有其对应的包装类:
byte
Byte
short
Short
"char
Character
"int
Integer
long
Long
float
Float
double
Double
boolean
Boolean

4.2 Integer包装类介绍

Integer是int基本类型的包装类

4.3 Integer类的构造方法和静态方法【了解】

构造方法:
public Integer(int value);
public Integer(String value);
静态方法:
public static Integer valueOf(int value);
public static Integer valueOf(String value);
public class TestInteger {
public static void main(String[] args) {
//1.创建Integer对象
//构造方法
Integer i1 = new Integer(10);
System.out.println(i1);
Integer i2 = new Integer("99");
System.out.println(i2);
//静态方法
Integer i3 = Integer.valueOf(11);
System.out.println(i3);
Integer i4 = Integer.valueOf("88");
System.out.println(i4);
}
}

4.4 拆箱和装箱

装箱:
把基本类型 --转成--> 对应包装类【重点】
拆箱:
包装类 --转回--> 对应的基本类型【重点】
比如:
Integer i1 = new Integer(10);
一种装箱操作
Integer i3 = Integer.valueOf(11); 一种装箱操作
int value = i1.intValue();
一种拆箱操作

4.4 自动拆箱和装箱【重点】

在JDK1.5中,引入了自动拆装箱操作
Integer i = 10; //底层Integer.valueOf(11)自动帮助我们进行装箱操作
int value = i; //底层 i.intValue()自动帮助我们进行拆箱操作
思考题:以下代码进行几次自动装箱和自动拆箱操作??
Integer a = 10; // 装1
a++; // a = a + 1
拆1
装1
自动装箱几次? 2
自动拆箱几次? 1

4.5 基本类型与字符串之间的转换【面试题】

• 基本类型 转成 String

  int num = 10;
  a.直接+一个""
  String s = num + "";
  b.通过String的静态方法valueOf
  String s = String.valueOf(num);
  

• String 转成 基本类型

  String num = "100";
  第一种方式:
  a.先使用Integer的构造方法
  Integer i = new Integer(num);
  b.接着调用intValue方法拆箱
  int number = i.intValue();
  c.或者不调用intValue自动拆箱即可
  int number = i;
  第二种方式:
  直接调用包装类的parseXxx(String s)解析字符串的方法
  int number = Integer.parseInt(num);
  

• 字符串无法解析成基本类型时的异常

  public class TestInteger02 {
  public static void main(String[] args) {
  //1.字符串
  String num = "999";
  //2.使用Integer.parseInt方法解析
  int number = Integer.parseInt(num);
  System.out.println(number);
  //3.如果num中的值无法解析成int,会抛出异常
  num = "999我爱你";
  //NumberFormatException 数字格式化异常
  int result = Integer.parseInt(num);
  System.out.println(result);
  }
  }
  

第五章 String类常用方法【重点】

String的构造方法:
直接赋值:
String s = "java";
构造方法:
String s = new String("java");
char[] chs = {'j','a','v','a'};
String s = new String(chs);
byte[] bs = {97,98,99,100};
String s = new String(bs); // s字符串最终的内容是:"abcd"
//5.1 concat 拼接
//方法原型：public String concat (String str)
//5.2 contains 判断是否包含某个小字符串
//方法原型：public boolean contains (CharSequence s)

//5.3 endsWith 是否以xx结尾
//方法原型：public boolean endsWith(String suffix)
//5.4 startsWith 是否以xx开头
//方法原型：public boolean startsWith(String prefix)
//5.5 indexOf 查找目标字符串在当前字符串中第一次出现的索引
//方法原型：public int indexOf(String str)
//5.6 lastIndexOf 查找目标字符串在当前字符串中最后一次出现的索引
//方法原型：public int lastIndexOf(String str)
//5.7 replace 将当前字符串中的目标字符串,替换为另外一个字符串
//方法原型：public String replace(CharSequence s1,CharSequence s2)
//5.8 substring 截取子串
//方法原型：public String substring(int beginIndex)
//方法原型：public String substring(int beginIndex, int endIndex);(含头不含尾)
//5.9 toCharArray 将字符串转成char数组
//方法原型：public char[] toCharArray()
//5.10 toLowerCase 转成纯小写
//方法原型： public String toLowerCase()
//5.11 toUpperCase 转成纯大写
//方法原型：public String toUpperCase()
//5.12 trim 取出字符串两端的空格(不去除空间的空格)
//方法原型：public String trim()
//5.13 split 切割字符串,参数称为切割符
//方法原型：public String[] split(String regex)
public class TestStringDemo {
public static void main(String[] args) {
String s = "HelloWorldHelloWorld";
//1.concat
String s1 = s.concat("Java");
System.out.println(s1);
//2.contains
boolean b1 = s.contains("oWo");
System.out.println(b1);
//3.startsWith endsWith
boolean b2 = s.startsWith("Hell");
boolean b3 = s.endsWith("orld");
System.out.println(b2);
System.out.println(b3);
//4.indexOf lastIndexOf
int index1 = s.indexOf("oWo");
System.out.println(index1);
int index2 = s.lastIndexOf("oWo");
System.out.println(index2);
//思考:如果没有找到目标字符串,返回什么??
int index3 = s.indexOf("PHP");
System.out.println(index3);
//5.replace
String s3 = s.replace("World", "Java");
System.out.println(s3);
//6.substring
//"HelloWorldHelloWorld"
String s4 = s.substring(10); //从10索引截取到最后
System.out.println(s4);
String s5 = s.substring(10, 15); //从10索引截取到15之前(不包含15索引)
System.out.println(s5);
//7.toCharArray
char[] chs = s.toCharArray();
System.out.println(Arrays.toString(chs));
//8.toLowerCase toUpperCase
String s6 = s.toLowerCase();
System.out.println(s6);
String s7 = s.toUpperCase();
System.out.println(s7);
//9.trim
String ss = "
Hello
World
";
System.out.println(ss);
String s8 = ss.trim();
System.out.println(s8);
//10.split 切割
String sss = "张胜男爱李四爱王五爱赵六爱前妻";
String[] names = sss.split("爱");
System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);
System.out.println(names[3]);
System.out.println(names[4]);
}
}

第六章 引用类型使用小结【难点&&重点】

主要是(普通类,抽象类,接口,以及多态)复习
基本类型,可以作为方法的参数和返回
public void show(int a){
}
public int method(){
}
普通类,也可以作为方法的参数和返回
public void show(Dog d){
}
public Dog method(){
}
抽象类,也可以作为方法的参数和返回
public void show(Animal a){
//Animal a = 任意一个子类对象
}
public Animal method(){
}
接口,也可以作为方法的参数和返回
public void show(Flyable a){
//Flyable a = 该接口的某个实现类对象
}
public Flyable method(){
}
总结:
当基本类型作为方法的参数和返回值时,调用方法和返回数据时,返回该基本类型的值即可
当引用类型作为方法的参数和返回值时,调用方法和返回数据时,返回该引用类型的对象/子类对象/实现类对象

6.1 类名作为方法参数和返回值

6.1 普通类作为方法参数和返回值

public class TestPerson {
public static void main(String[] args) {
//调用方法
killPerson(new Person(18,"前妻"));
//调用方法
Person pp = birthPerson();
System.out.println(pp);
}
//定义方法,使用普通类Person,作为方法的参数
public static void killPerson(Person p) {
System.out.println("给老子去死~~");
System.out.println(p);
}
//定义方法,使用普通类Person,作为方法的返回值
public static Person birthPerson() {
//返回一个Person对象
//
Person p = new Person(3,"哪吒");
//
return p;
return new Person(3,"哪吒");
}
}
结论: 当方法的参数或者返回值是普通类时,我们要传入或者返回的是该类的对象

6.2 抽象类作为方法参数和返回值

public class TestAnimal {
public static void main(String[] args) {
//调用方法
show(new Dog());
show(new Cat());
System.out.println("=======");
//调用方法
Animal an = birthAnimal();
an.eat();
an.bark();
}
//定义一个方法,使用抽象类Animal作为方法的参数
public static void show(Animal an){
//Animal an = new Dog();
//Animal an = new Cat();
an.eat();
an.bark();
}
//定义一个方法,使用抽象类Animal作为方法的返回值
public static Animal birthAnimal(){
//返回Animal的子类对象
return new Dog();
//
return new Cat();
}
}
结论:当方法的参数或者返回值是抽象类时,我们要传入或者返回的是该抽象类的子类对象

6.3 接口作为方法参数和返回值

public class TestFlyable {
public static void main(String[] args) {
//调用
showFly(new Bird());
showFly(new Plane());
System.out.println("=====");
//调用
Flyable ab = getFly();
ab.fly();
}
//定义方法,使用接口Flyable作为方法参数
public static void showFly(Flyable fa){
//Flyable fa = new Bird();
//Flyable fa = new Plane();
fa.fly();
}
//定义方法,使用接口Flyable作为方法返回值
public static Flyable getFly() {
//返回Flyable的实现类对象
return new Bird();
//
return new Plane();
}
}
结论:当方法的参数或者返回值是接口时,我们要传入或者返回的是该接口的实现类对象

基本类型可以作为类的成员变量的,其实引用类型也可以作为类的成员变量

public class Student{
int age;//学生有年龄
String name;//学生有姓名
Dog dog;//学生有只狗
Animal an;//学生有只动物
Flyable fa;//学生有个会飞的东西
}

6.4 普通类作为成员变量

/**
* 身份证类
*/
public class IDCard {
String id; //号码
String years; //有效年限
String author;//签发机关
//...
public IDCard() {
}
public IDCard(String id, String years, String author) {
this.id = id;
this.years = years;
this.author = author;
}
@Override
public String toString() {
return "IDCard{" +
"id='" + id + ''' +
", years='" + years + ''' +
", author='" + author + ''' +
'}';
}
}
//人类
public class Person {
//人拥有一个年龄
int age;
//人拥有一张身份证
IDCard card;
public Person() {
}
public Person(int age, IDCard card) {
this.age = age;
this.card = card;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", card=" + card +
'}';
}
}
/**
* 测试类
*/
public class TestPerson {
public static void main(String[] args) {
//1.创建一张身份证
IDCard cc = new IDCard("10086","20","中国移动");
//2.创建一个人
Person pp = new Person(18,cc);
//3.打印
System.out.println(pp);
}
}
结论: 当普通类作为成员变量,给该成员变量赋值时,赋值普通类的对象

6.5 抽象类作为成员变量

public class Student {
int age;
String name;
//还有一只动物
Animal an;
//.....
}
public class TestStudent {
public static void main(String[] args) {
//1.创建一个学生
Student ss = new Student();
//2.给ss的成员变量赋值
ss.age = 18;
ss.name = "王五";
//
ss.an = new Dog();
ss.an = new Cat();
}
}
总结: 当抽象类作为成员变量时,给该成员变量赋值,赋该抽象类的子类对象

6.6 接口作为成员变量

public class Student {
private int age;
private String name;
//拥有一个会飞的东西
private Flyable fa;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Flyable getFa() {
return fa;
}
public void setFa(Flyable fa) {
this.fa = fa;
}
}
public class TestStudent {
public static void main(String[] args) {
//1.创建一个Student对象
Student ss = new Student();
//2.给age赋值
ss.setAge(10);
//3.给name赋值
ss.setName("张三");
//4.给fa赋值
//
ss.setFa(new Bird());
ss.setFa(new Plane());
}
}
结论: 当接口作为成员变量时,给该成员变量赋值,赋该接口的实现类对象

总结

1.BigInteger【理解】
2.BigDecimal 【理解】
add subtract multiply divide
3.Arrays工具类【重点】
public static void sort(int[] arr);默认对数组进行升序排序
public static String toString(int[] arr);将数组的所有元素拼接成一个大的字符串返回
4.包装类【重点】
a。八种基本类型对应的引用类型
b。装箱和拆箱（JDK5之后,自动拆装箱）
Integer i = 10;
int j = i;
5.String 【重点】
掌握构造方法+常用的13个成员方法(熟练使用)
6.引用类型的使用总结【重点+练习+思考】
引用类型作为方法的参数和返回值
引用类型作为成员变量
如果引用类型是普通类,那么需要用到该普通类的对象
如果引用类型是抽象类,那么需要用到该抽象类的子类对象
如果引用类型是接口,那么需要用到该接口的实现类对象

最后

以上就是紧张高山为你收集整理的day05 【常用API,引用类型小结】BigInteger类、BigDecimal类、Arrays类、包装类、String类、引用类型使用小结day05 【常用API,引用类型小结】的全部内容，希望文章能够帮你解决day05 【常用API,引用类型小结】BigInteger类、BigDecimal类、Arrays类、包装类、String类、引用类型使用小结day05 【常用API,引用类型小结】所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。