# Day09-Java基础

Posted 2021-09-02 zsr6135

Day09-Java

文章目录

• Day09-Java
• • • 1、匿名内部类
    • 2、Object类简介
    • • • 2.1 取得对象信息toString()
        • 2.2 对象的比较equals()
        • 2.3 Object接口引用数据类型
    • 3、包装类
    • • • 3.1 装箱与拆箱
        • 3.2 字符串与基本数据类型的转换
        • 3.3 包的定义
        • 3.4 包的导入
    • 4、访问控制权限
    • 5、jar命令

1、匿名内部类

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

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就没有什么意义了，但是可以利用匿名内部类的概念来解决此问题。匿名内部类是在抽象累和接口的基础之上发展起来的。

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对象
	}
}

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

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

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()方法的功能。

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()。

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没有任何明确的关系。

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接收。

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

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为例

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为例

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提供了自动装箱和自动拆箱的机制，并且包装类的对象可以自动的进行数学计算了。

自动装箱与拆箱

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

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

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

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

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型数据

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型数据；

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)

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

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完成，下面通过一个程序进行演示。

//定义一个Message
package cn.mldn.util;//打包
class Massage{
	public String print(){
		return "Hello World";
	}
}

//定义另外一个类使用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，但是这个时候出现了一下的错误提示：

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文件，使

以上是关于# Day09-Java基础的主要内容，如果未能解决你的问题，请参考以下文章

java小白训练营day01-基础环境搭建

Java 微服务 day01 源代码 Java的配置

Java 微服务 day02 源代码 SpringBoot 属性注入 自动配置

Java 微服务 day01 源代码 SpringBoot的SpringMVC快速入门

Java 微服务 day02 源代码 SpringBoot 实战开发 SpringMVC高级配置：拦截器：HandlerExecutionChain

Java 微服务 day02 源代码 SpringBoot 实战开发 整合JDBC和事务（数据库连接池）