java基础的详细了解第九天

时间：2021-10-22 15:40:23

1、匿名内部类

内部类：在一个类的内部定义了另外的类，称为内部类，匿名内部类指的是没有名字的内部类。为了清楚内部类的主要作用，下面首先观察一个代码。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface IMessage{
    public void print();
}
class MessageImpl implements IMessage{//定义接口实现类
    public void print(){
        System.out.println("Hello World");
    }
}
class Demo{
    public static void get(IMessage msg){//接受接口对象
        msg.print();
    }
}
public class TestDemo1{
    public static void main(String args[]){
        IMessage msg = new MessageImpl();//子类为接口实例化
        Demo.get(msg);//传递msg对象
    }
}

如果说现在MessageImpl这个子类只使用一次，有必要按照以上的方式进行定义吗？

这个时候MessageImpl就没有什么意义了，但是可以利用匿名内部类的概念来解决此问题。匿名内部类是在抽象累和接口的基础之上发展起来的。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
interface IMessage{
    public void print();
}
class Demo{
    public static void get(IMessage msg){//接受接口对象
        msg.print();
    }
}
public class TestDemo1{
    public static void main(String args[]){
        IMessage msg = new IMessage(){//匿名内部类
            public void print(){
                System.out.println("hello,world!");
            }
        };
        Demo.get(msg);//传递msg对象
    }
}

结论：基本上搞匿名内部类都应该在接口或抽象类形式上完成。

在抽象类中使用匿名内部类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
abstract class Message{
    public void print(){
        System.out.print(this.getInfo());
    }
    public abstract String getInfo();
}
class Demo{
    public static void get(Message msg){//接受接口对象
        msg.print();
    }
}
public class TestDemo1{
    public static void main(String args[]){
        Demo.get(new Message(){
            public String getInfo(){
                return "www.baidu.com";
            }
        });//传递msg对象
    }
}

强调：一个普通类进行不要再去有子类进行继承，能够继承的只是抽象类和接口，所以在普通类上继续使用

匿名内部类的形式来定义子类，但是在正常的开发逻辑上是错误的。

2、Object类简介

在Java的定义之中，除了Object类之外，所有的类实际上都存在继承关系，即：如果现在定义了一个类，没有默认继承任何一个父类的话，则默认讲继承Object类，以下两种类最终定义效果是完全一样的。

Object类的无参构造是专门子类提供服务的。

方法名称 类型 描述
public String toString() 普通 取得对象信息
public boolean equals(Object obj) 普通 对象的比较
public int hashCode() 普通 返回对象的哈希码值

2.1 取得对象信息toString()

toString()的核心目的在于取得对象信息。相当于替换了getInfo()方法的功能。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Person{
    private String name;
    private int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return "name = " + this.name + ",age = " + this.age ;
    }
}
public class TestDemo2{
    public static void main(String args[]){
        Person p = new Person("zsr",18);
        System.out.print(p.toString());
    }
}

2.2 对象的比较equals()

实际上对于equals()方法应该并不陌生，这个方法在String类中见过，String是Object类的子类，所以String类的equals()方法就是覆写了Object类中的equals()方法，在Object类之中，默认的equals()方法实现比较的是两个对象的内存地址数值，但是并不符合与真正的对象比较需要。对象比较之前也写过，但是之前那是自己定义的一个新的方法名称，今天可以给出标准的方法名称：equals()。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Person{
    private String name;
    private int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object anObject){
        if(anObject == null){
            return false;
        }
        if(this == anObject){
            return true;
        }
        //判断anObject的实例是不是Person
        if( !(anObject instanceof Person)){
            return false;
        }
        //必须将Object类型变为Person类型后才可以调用name和age属性
        Person per = (Person) anObject;
        return this.name.equals(per.name) && this.age == per.age;
    }
    public String toString(){//覆写Object类方法
        return "name = " + this.name + ",age = " + this.age ;
    }
}
public class TestDemo3{
    public static void main(String args[]){
        Person per1 = new Person("zsr",18);
        Person per2 = new Person("zsr",18);
        //true
        System.out.println(per1.equals(per2));
        //false
        System.out.println(per1.equals("Hello,world!"));
    }
}

但是需要有一个注意，很多人在写对象的比较会使用如下的形式：

  • public boolean equals(Person anObject)

因为父类中的equals()方法用的是Object，所以以上的方法严格来讲已经不叫覆写，叫重载。

2.3 Object接口引用数据类型

在之前的分析来讲Object可以接收任意的对象，从结构上来讲Object是所有类的父类，但是Object概念并不仅仅局限于此，他已接收所有的引用数据类型，包括：接口、数组。

使用Object类接收数组，数组和Object没有任何明确的关系。

?
1
2
3
4
5
6
7
8
9
public class TestDemo4{
    public static void main(String args[]){
        Object obj = new int []{1,3,4};
        int data [] = (int [])obj;//向下转型
        for(int i = 0 ;i < data.length ; i++){
            System.out.println(data[i]);
        }
    }
}

接收接口对象，从接口的定义而言，它是不能去继承一个父类的，但是由于接口依然属于引用类型，所以即使没有继承类，也可以使用Object接收。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
interface Message{}
class MessageImpl implements Message{//定义接口子类
    public String toString(){
        return "Hello World";
    }
}
public class TestDemo5{
    public static void main(String args[]){
        Message msg = new MessageImpl();//向上转型
        Object obj = msg;//向上转型
        Message temp = (Message) obj;//向下转型
        System.out.println(temp);//toString()
    }
}

从代码上讲，以上只能算是一个固定的操作概念，不过从实际来讲，因为有了Obejct类的出现，所有的操作就可以达到统一，那么之前的链表程序，就应该变得很方便了。所有的数据都使用Object接收，所有的对象比较（删除、查找）都可以使用equals()。

3、包装类

在Java的设计之中，一直倡导一个原则：一切皆对象，这个原则本省有一个漏洞，基本数据类型不是对象，所以这个原则就出现了问题，那么如果说现在这个问题由我们来解决，该如何解决呢？

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyInt{
    private int num;//基本类
    public MyInt(int num){
        this.num=num;
    }
    public int intValue(){
        return this.num;
    }
}
public class TestDemo6{
    public static void main(String args[]){
        Object obj = new MyInt(10);//子类自动变为Object父类对象
        MyInt temp = (MyInt) obj;//向下转型
        int result = temp.intValue();
        System.out.println(result*result);
    }
}

以上的操作是将基本类型变为了一个对象的形式进行操作了，但是这里面有一个问题：基本数值型数据是可以进行数学运算的，可是以上变为了类的形式，那么肯定无法直接计算了。以上的问题既然我们都想到方法解决，那么Java也一定早已解决，为此它专门提供了八种包装类：

byte(Byte),short(Short),int(Integer),long(Long),float(Float),double(Double),boolean(Boolean),char(Character);

而这八种包装类有分为两大阵营：

​ 数值型（Number子类）：Byte,Short,Integer(int),Float,Double,Long;

​ 对象型（Object子类）：Boolean,Character(char)。

可是对于Number的子类，就必须观察出Number类之中定义的方法：byteVlue()、intVlue()、doubleVlue()、shortVlue()、longVlue()、floatVlue()，就是从包装的类之中取得所包装的数值。

3.1 装箱与拆箱

在基本数据类型和包装类之间的转化之中分为两个重要概念：

​ 装箱操作：将基本数据类型变为包装类，称为装箱，包装类的构造方法。

​ 拆箱操作：将包装类变为基本数据类型，称为拆箱，Number类中的xxValue()方法。

以int和Integer为例

?
1
2
3
4
5
6
7
public class TestDemo{
    public static void main(String args[]){
        Integer var = new Integer(10);//装箱
        int result = var.intValue();//拆箱
        System.out.println(result*result);
    }
}

以double和Double为例

?
1
2
3
4
5
6
7
public class TestDemo{
    public static void main(String args[]){
        Double var = new Double(10.0);//装箱
        double result = var.doubleValue();//拆箱
        System.out.println(result*result);
    }
}

以上的操作实在JDK1.5之前所进行的必须的操作，但是到了JDK1.5之后，Java提供了自动装箱和自动拆箱的机制，并且包装类的对象可以自动的进行数学计算了。

自动装箱与拆箱

?
1
2
3
4
5
6
7
8
public class TestDemo{
    public static void main(String args[]){
        Integer var = 10;//自动装箱
        int result = var;//自动拆箱
        //可以直接利用包装类进行对象操作
        System.out.println(++var*result);//自动进行数学运算
    }
}

但是到此为止还有一个小问题，实际上这一问题之前已经见过。

?
1
2
3
4
5
6
7
8
9
10
11
public class TestDemo{
    public static void main(String args[]){
        Integer x = new Integer(10);//新空间
        Integer y = 10;//入池
        Integer z = 10;
        System.out.println(x==y);//false
        System.out.println(x==z);//false
        System.out.println(y==z);//ture
        System.out.println(x.equals(y));//ture
    }
}

使用包装类的时候还需要考虑equals()和==的区别。

使用int还是Integer?

  • 在接收数据的时候，使用的一定都是int，而保存数据的时候一般使用Integer
  • 以后编写的简单java类统一不要再去使用基本数据类型，全部换位包装类

3.2 字符串与基本数据类型的转换

包装类之中所提供的最大优点在于可以讲字符串变为制定的基本数据类型，下面列出几个操作：

​ Integer类：public static int parseInt(String s);

​ Double类：public static double parseDouble(String s);

​ Boolean类：public static boolean parseboolean(String s;

但是character这个包装类之中，并没有提供一个类似的parseCharacter()，因为字符串String类之中提供了一个charAt()方法，可以取得制定索引的字符，而且一个字符的长度就是一位。

将字符串变为int

?
1
2
3
4
5
6
7
public class TestDemo{
    public static void main(String args[]){
        String str = "16";
        int result = Integer.parseInt(str);//String ——>int
        System.out.println(result*result);
    }
}

但是需要提醒的是，在执行这种转化的操作过程之中，字符串字符串中的全部内容必须由数字所组成，如果有一位内容不是数字，则在转化的过程之中讲出现如下的错误提示：NumbnerFormatException。

将字符串变为double

?
1
2
3
4
5
6
7
public class TestDemo{
    public static void main(String args[]){
        String str = "16.";
        double result = Double.parsedouble(str);//String ——>int
        System.out.println(result*result);
    }
}

将字符串变为boolean型数据

?
1
2
3
4
5
6
7
public class TestDemo{
    public static void main(String args[]){
        String str = "true";
        boolean result = Boolean.parseboolean(str);//String ——>int
        System.out.println(result);
    }
}

提示：在使用Boolean型包装类的时候，如果字符串之中的内容不是true或者是false，统一都按照false处理。

以上的操作是通过字符串变为一些基本类型的数据，但是反过来讲，基本数据类型如何变为字符串呢？

方式一：任何基本数据类型遇到了String之后都会变为String型数据；

?
1
2
3
4
5
6
7
8
public class TestDemo{
    public static void main(String args[]){
        int num = 100;
        String str = num+"";//int——>String //会产生垃圾
        System.out.println(str.length());
    }
}
//会有垃圾产生

方式二：利用String方法，public static String valueOf(数据类型 b)

?
1
2
3
4
5
6
7
public class BaoZhuangLei{
    public static void main(String args[]){
        int num = 100;
        String str =String.valueOf(num);//int——>String
        System.out.println(str.length());
    }
}

3.3 包的定义

在Java程序之中的包，主要的目的是可以将不同功能的文件进行分割，在之前的代码开发之中，所有的程序都保存在了同一个目录之中，这样一来所带来的问题：如果出现了同名的文件，那么会发生覆盖问题，因为在同一个目录之中不允许有重名的文件，而在不同的目录下可以有重名文件，所谓的包实际上指的就是文件夹。

?
1
2
3
4
5
6
package cn.mldn.demo;//定义包
public class Hello{
    public static void main(String args[]){
        System.out.println("Hello World");
    }
}

一旦定义完成之后，那么这个类的名字就成了“cn.mldn.demo.Hello”，即这既是完整的类名称，而在进行程序编译的时候也需要将*.class文件保存在包之中，于是为了方便开发，那么也就提供了一个打包的编译操作。

打包编译：javac -d . 类.java

-d:表示生成目录，根据package定义生成

-“.”:再当前目录下生成*.class

类.java:编译源程序代码

这个时候类的名字必须带上包的名称，所以执行类的时候：java cn.mldn.demo.Hello，也就是说完整类的名称就是“包.类”，而在所有的开发之中，没有包的类是绝对不存在的，只要是程序一定要有包。

3.4 包的导入

既然使用包可以将一个大型的程序拆分成不同的功能目录保存，那么这些不同的包之间也一定会存在包的导入问题，而导入包在程序之中使用import完成，下面通过一个程序进行演示。

?
1
2
3
4
5
6
7
//定义一个Message
package cn.mldn.util;//打包
class Massage{
    public String print(){
        return "Hello World";
    }
}
?
1
2
3
4
5
6
7
8
9
//定义另外一个类使用Message类
package cn.mldn.text;//打包
import cn.mldn.util.Message;//导入包
public class Text{
    public static void main(String args[]){
        Massage msg = new cn.mldn.util.Massage();
        System.out.println(msg.print());
    }
}  

这个时候上面的两个类应该是按照顺序编译：

​ 应该首先编译Message.java程序：javac –d . Message.java;

​ 再次编译Test.java程序：javac –d . Test.java，但是这个时候出现了一下的错误提示：

?
1
2
3
4
Text.java:5: 错误: Massage在cn.mldn.util中不是公共的; 无法从外部程序包中对其进行
访问
                Massage msg = new cn.mldn.util.Massage();
                ^

提示：关于public class 和class定义类的区别

​ Public class：文件名和类名称保持一致，在一个*.java文件之中只能存在一个public class定义，如果一个类要想被外部包所访问必须定义为public；

​ Class：文件名称可以和类名称不一致，在一个*.java之中可以同事存在多个class定义，并且编译完成之后会形成多个*.class文件，使用class定义的类只能够在一个包中访问，不同包之间无法访问。

?
1
2
3
4
5
6
package cn.mldn.util;//打包
public class Massage{
    public String print(){
        return "Hello World";
    }
}

但是同时也发现了一个问题，现在这些类在编译的时候要有顺序，实在很麻烦，为此在java之中专门提供了一个可以进行自动连编的操作，编译的时候使用*.java：javac –d . .java，将一个目录之中所有的.java文件进行编译。

​ 但是以上的代码还有一个小问题：程序在进行导入的时候使用了“包.类”的完整名称完成的，但是如果在一个程序之中要同时导入一个包的多个类的时候，那么分开去编写实在很麻烦，为此可以使用通配符“*”完成导入。

?
1
2
3
4
5
6
7
8
package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
public class Text{
    public static void main(String args[]){
        Massage msg = new cn.mldn.util.Massage();
        System.out.println(msg.print());
    }
}  

但是需要注意的是，在java之中使用“”或者是的单独导入，其从实际的操作性能上是没有任何区别的，因为即使使用了也表示导入所需要的类，不需要的不导入。

​ 可是在导入包的时候也会遇到一种比较麻烦的问题：会导入不同包的同名类，例如：对于Message类，现在在两个包中都有：cn.mldn.util cn.mldn.info

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
import cn.mldn.info.*;//导入包
public class Text{
    public static void main(String args[]){
        Message msg = new cn.mldn.util.Message();
        System.out.println(msg.print());
    }
}
/*
Text.java:6: 错误: 对Message的引用不明确, cn.mldn.info中的类 cn.mldn.info.Messag
e和cn.mldn.util中的类 cn.mldn.util.Message都匹配
                Message msg = new cn.mldn.util.Message();
                ^
*/

由于某种需要，同时导入两个包，这个时候要使用Message类的时候必须加上类的全名。

?
1
2
3
4
5
6
7
8
9
package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
import cn.mldn.info.*;//导入包
public class Text{
    public static void main(String args[]){
        cn.mldn.util.Message msg = new cn.mldn.util.Message();
        System.out.println(msg.print());
    }
}

4、访问控制权限

之前学习到的private就属于一种访问控制权限，而这种访问控制权限只是封装的一部分，再java里面提供有四种访问控制权限：private、default、protected、public，而这四种访问控制权限定义如下：

范围 private default protected public
同一包中的同一类 √ √ √ √
同一包中不同类   √ √ √
不同包中的子类     √ √
不同包中的非子类       √

实际上public永远都可以访问，但是对于封装而言主要使用三个权限：private、default、protected。

观察protected访问权限

Info.java

?
1
2
3
4
5
package cn.sxau.demo.a;
public class Info {
//protected权限
    protected String str = "www.baidu.com";
}

SubInfo.java

?
1
2
3
4
5
6
7
package cn.sxau.demo.a;
import cn.sxau.demo.a.Info;
public class SubInfo extends Info{
    public void print(){
        System.out.println(super.str);
    }
}

TestInfo.java

?
1
2
3
4
5
6
7
package cn.sxau.testab;
import cn.sxau.demo.a.SubInfo;
public class TestInfo{
    public static void main(String args[]){
        new SubInfo().print();
    }
}

java基础的详细了解第九天

可以发现SubInfo继承的子类Info不在同一个包内，但是在同一个子类中，并且可以调用其子类。

错误代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package cn.sxau.testab;
import cn.sxau.demo.a.Info;
public class TestInfo{
    public static void main(String args[]){
        System.out.println(new Info().str);
    }
}
/*
F:\java\javabase\day09>javac -d . TestInfo.java
TestInfo.java:5: 错误: str 在 Info 中是 protected 访问控制
                System.out.println(new Info().str);
                                             ^
1 个错误
*/

原因是str是protected权限，所以在不同类非子类的类中是无法访问。

对于权限的选择

  • 对于封装的描述大部分情况下都使用的是private,很少的情况下使用protected，这两个都叫封装
  • 属性都是以private，方法都使用public。

封装性就是指private、protected、default三个权限的使用。

5、jar命令

Jar是一种java给出的压缩格式文件，即：可以将*.class文件以*.jar压缩包的方式给用户，这样方便程序的维护，如果要使用jar的话，可以直接利用JDK给出的jar命令完成。

java基础的详细了解第九天

c：创建一个新的归档文件

f：指定jar的文件名称，由用户制定一个*.jar的文件名。

v：生成标准的压缩信息

Message.java

?
1
2
3
4
5
6
package cn.sxau.util;//打包
public class Message{
    public String print(){
        return "hello world";
    }
}

将Message.java程序进行编译：javac –d . Message.java，生成包.类；将“包.类”压缩成my.jar文件：jar –cvf my.jar cn，出现了一个my.jar包；

此时my.jar就包含了所需要的程序使用类

现在my.jar和MyTest.java处于同一目录之中。但是发现找不到my.jar之中定义的内容，这是因为在java之中每一个*.jar文件都属于一个独立的CLASSPATH路径，如果要想使用，必须配置CLASSPATH。

在测试之前需要在cmd配置SET CLASSPATH=.;F:\java\javabase\day09\my.jar

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//定义一个测试类 调用my.jar
package cn.sxau.test;
public class MyTest{
    public static void main(String args[]){
        cn.sxau.util.Message msg = new cn.sxau.util.Message();
        System.out.println(msg.print());
    }
}
/*
执行
F:\java\javabase\day09>java cn.sxau.test.MyTest
hello world
*/

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注服务器之家的更多内容！

原文链接：https://blog.csdn.net/zsr6135/article/details/119493639

标签：

相关文章