Java——匿名内部类、Object类、Scanner类、String类、StringBuffer类、基本数据类型包装类和数组排序

最新推荐文章于 2021-02-27 10:26:31 发布

云祁

最新推荐文章于 2021-02-27 10:26:31 发布

阅读量1k

点赞数

文章标签： Java基础

本文链接：https://blog.csdn.net/BeiisBei/article/details/100608784

版权

---- Java 基础专栏收录该内容

43 篇文章 1 订阅

订阅专栏

文章目录

匿名内部类

在这里插入图片描述

匿名内部类时局部内部类的简写，使用代码如下：

 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;
    }
}

云祁

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java——匿名内部类、Object类、Scanner类、String类、StringBuffer类、基本数据类型包装类和数组排序

文章目录匿名内部类Object类Scanner类String类StringBuffer类包装类基本类型转换为String包装类Integer类数组排序匿名内部类匿名内部类时局部内部类的简写，使用代码如下： public abstract class Animal { public abstract void eat();}public interface MyInterFace...
复制链接

扫一扫

专栏目录