匿名内部类
匿名内部类时局部内部类的简写,使用代码如下:
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类
Objects类
在刚才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提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:
基本类型 | 对应的包装类(位于java.lang包中) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
装箱与拆箱
基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:
-
装箱:从基本类型转换为对应的包装类对象。
-
拆箱:从包装类对象转换为对应的基本类型。
用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;
}
}