文章目录
匿名内部类
Object类
Objects类
Scanner类
String类
StringBuffer类
包装类
基本类型转换为String
包装类Integer类
数组排序
匿名内部类
匿名内部类时局部内部类的简写，使用代码如下：
public abstract class Animal { public abstract void eat(); } public interface MyInterFace { public abstract void method(); } public class Dog { public Animal dshow(){ return (new Animal() { @Override public void eat() { System.out.println("匿名内部类作为返回值"); } }); } public MyInterFace dshow1() { return (new MyInterFace() { @Override public void method() { System.out.println("匿名内部类作为返回值"); } }); } } public class Test { public static void main(String[] args) { //匿名内部类作为show（）的形参第一种形式 show(new Animal() { @Override public void eat() { System.out.println("匿名内部类直接作为方法的形参"); } }); System.out.println("-----------------------------------"); //匿名内部类作为show（）的形参第二种形式 Animal an1=new Animal() { @Override public void eat() { System.out.println("匿名内部类间接作为方法的形参"); } }; show(an1); System.out.println("-----------------------------------"); //匿名内部类作为返回值 Dog dog=new Dog(); Animal an2=dog.dshow(); show(an2); System.out.println("-----------------------------------"); Dog dog1=new Dog(); MyInterFace my =dog1.dshow1(); show1(my); } public static void show(Animal an){ an.eat(); } public static void show1(MyInterFace my){ my.method(); } }
需要注意的是：向下转型
Object类
在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？
在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：
public static boolean equals(Object a, Object b):判断两个对象是否相等。
我们可以查看一下源码，学习一下：
public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); }
Scanner类
String类
注意：
（1）对String类的特点：字符串被创建，其值不在改变，改变的是其引用的值，利用内存图对其进行详解：
（2）对String s=new String(“hello”)和String s1="hello"的区别，利用内存图展示：
（3）理解好含左不含右的意义。
StringBuffer类
（1）String和StringBuffer的相互转换，代码如下：
public class StringBufferTest2 { public static void main(String[] args) { //String-----StriingBuffer String str="sgjjlk"; StringBuffer stringBuffer1 = new StringBuffer(str); StringBuffer stringBuffer2 = new StringBuffer().append(str); System.out.println(stringBuffer1); System.out.println(stringBuffer2); System.out.println("-------------------------------"); //StringBuffer-------String StringBuffer s1 = new StringBuffer("cvhjbjk"); String s2 = s1.toString();//toString()是转换为字符串输出 System.out.println(s2); String s3 = s1.substring(0);//substring()截取字符串，返回的是字符串类型 System.out.println(s3); } }
（2）String和StringBuffer的作为形参的区别，代码如下：
public class StringBUffertest3 { public static void main(String[] args) { /*String 作为形参，虽然是引用类型，但是是一个常量， 可以作为基本数据类型进行数据传递，但是其形参的改变不会改变实参的值 * */ String str="asdfg"; setString(str); System.out.println(str); /** * StringBuffer作为形参，其是引用类型，形参的改变会影响实参的改变 */ StringBuffer s= new StringBuffer("asdfghjkl"); setStringBuffer(s); System.out.println(s); } public static void setString(String str){ str = str.replace('d', 'e'); System.out.println(str); } public static void setStringBuffer(StringBuffer str){ str=str.append("asdf").replace(2,5,"ty"); System.out.println(str); } }
包装类
Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：
装箱与拆箱
基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：
- 装箱：从基本类型转换为对应的包装类对象。
- 拆箱：从包装类对象转换为对应的基本类型。
用Integer与 int为例：（看懂代码即可）
基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数 Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象---->基本数值
int num = i.intValue();
自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4); i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; //加法运算完成后，再次装箱，把基本数值转成对象。
基本类型与字符串之间的转换
基本类型转换为String
基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲最简单的一种方式：
基本类型直接与””相连接即可；如：34+""
String转换成对应的基本类型
除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
- public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
- public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
- public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
- public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
- public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
- public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
- public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
代码使用（仅以Integer类的静态方法parseXxx为例）如：
public class Demo18WrapperParse { public static void main(String[] args) { int num = Integer.parseInt("100"); } }
注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。
包装类Integer类
（1）int与String的相互转换代码：
public class Test { public static void main(String[] args) { //int ------------String int num=1000; //字符串的拼接 String str=""; str+=num; System.out.println(str); System.out.println("-----------------------"); //valueOf(),将任意的数据类型转换为字符串 String s = String.valueOf(num); System.out.println(s); System.out.println("-----------------------"); //int---Integer---String Integer i1 = new Integer(num); String s1 = i1.toString(num);//toString()必须对象调用方法 System.out.println(s1); System.out.println("-----------------------"); //String-----int String st="111111"; Integer in1 = new Integer(st); int in2 = in1.intValue(); //不是静态方法，返回的是int型数字 System.out.println(in2); System.out.println("----------------------"); int in3 = Integer.parseInt(st); //静态的方法，只能通过类名来调用 System.out.println(in3); } }
特别注意，静态方法的调用时类名调用而不是对象的调用。
数组排序
（1）冒泡排序代码：
import java.util.Arrays; public class MaoPaoSort { public static void main(String[] args) { int[] arr={24,69,80,57,13}; sort(arr); } public static void sort(int[] arr){ for(int i=0;i<arr.length;i++){ for(int j=0;j<arr.length-1-i;j++){ if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } System.out.println(Arrays.toString(arr)); } }
（2）选择排序代码:
public class XUanZeTest { public static void main(String[] args) { int[] arr={24,69,80,57,13}; sort(arr); } public static void sort(int[] arr){ for(int i=0;i<arr.length-1;i++){ for(int j=i+1;j<arr.length;j++){ if(arr[i]>arr[j]){ int temp = arr[i]; arr[i] = arr[j ]; arr[j] = temp; } } } System.out.println(Arrays.toString(arr)); } }
（3）二分法排序代码：
public class ErFenFa { public static void main(String[] args) { int[] arr={12,54,2,4,89}; sort(arr); int index=erfenfa(arr,4); System.out.println(index); } public static void sort(int[] arr){ for(int i=0;i<arr.length;i++){ for(int j=0;j<arr.length-1-i;j++){ if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } System.out.println(Arrays.toString(arr)); } public static int erfenfa(int[] arr,int value){ int minIdex=0; int maxIndex=arr.length-1; int midIndex=(minIdex+maxIndex)/2; while(minIdex<=maxIndex) { if (value == arr[midIndex]) { System.out.println("找到对应的值，索引值为：" ); return midIndex; } else if (value < arr[midIndex]) { maxIndex = midIndex - 1; } else { minIdex = midIndex + 1; } midIndex=(minIdex+maxIndex)/2; } return -1; } }
