JavaAPI的使用、Math类、包、Scanner类、内部类、访问限定修饰符 Java第八天

最新推荐文章于 2023-11-16 21:49:14 发布

admin_233

最新推荐文章于 2023-11-16 21:49:14 发布

阅读量243

点赞数

分类专栏： Java学习之路文章标签： java

本文链接：https://blog.csdn.net/admin_233/article/details/104703139

版权

Java学习之路专栏收录该内容

29 篇文章 1 订阅

订阅专栏

Java第八天

API的使用
Math类
包(package)
- 不同包下的类访问
Scanner类(扫描器类)
内部类
访问限定修饰符

API的使用

定义：API是我们写代码的帮助文档，后续要接触很多第三方技术，他们都会提供API，所以我们必须会读懂，同样Jdk也提供了API文档。
用法：通过索引的方式根据类名来查找类的API信息。
注意：
①看包名，如果是java.lang下的类，则不用引入该包。
②看这个指定的类是具体类、抽象类还是接口，并且注意版本号。
③注意方法的类型、方法内的参数列表、返回值类型和成员方法的父类
④注意静态属性和构造器方法。

Math类

方法作用	语法
自然对数	`Math.E`
圆周率	`Math.PI`
取绝对值(double、float、int、long)	`Math.abs(数据类型值)`
将值的小数位去除，并将整数加一 (double)	`Math.ceil(double 值)`
将值的小数位舍弃(double)	`Math.floor(double 值)`
比较两个数的大小，返回最大值(double、float、int、long)	`Math.max(数据类型值1，数据类型值2)`
比较两个数的大小，返回最小值(double、float、int、long)	`Math.min(数据类型值1，数据类型值2)`
计算某个数的n次幂(double)	`Math.pow(double 参数,double 幂次)`
将目标值四舍五入(double、long) (double返回值为long,float返回值为int)	`Math.round(数据类型值)`
将目标值开平方(double)	`Math.sqrt(double 值)`

包(package)

定义：可以将包理解为文件夹。
作用：可以对类做分类管理，区分同名不同包的类。
包名要放在代码首行，注释不算。

package 包名;
//不同级用"."分隔
package example;
package com.example;

同一个包下的类可以直接访问。

不同包下的类访问

被访问的类的访问修饰限定符必须为public，但在同一包下可忽略。
①在被访问的类的前面加上包的全路径，但被访问的类需要先被编译出来。
②在package语句下使用引入语句

包路径.类名
import 包名.类名;

Scanner类(扫描器类)

作用：获取控制台输入的数据。
步骤：
①导入Scanner类
②创建Scanner对象
③使用其功能

import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("您输入的数值为：" + scanner.nextInt());
	}
}

以下是其他适用于Scanner的方法。

String next() 							查找并返回此扫描仪的下一个完整令牌。  
String next(Pattern pattern) 			如果匹配指定的模式，则返回下一个令牌。  
String next(String pattern) 			如果匹配从指定字符串构造的模式，则返回下一个令牌。  
boolean nextBoolean() 					将输入的下一个标记扫描为布尔值，并返回该值。  
byte nextByte() 						将输入的下一个标记扫描为 byte 。  
byte nextByte(int radix) 				将输入的下一个标记扫描为 byte 。  
double nextDouble() 					将输入的下一个标记扫描为 double 。  
float nextFloat() 						将输入的下一个标记扫描为 float 。  
int nextInt() 							将输入的下一个标记扫描为 int 。  
int nextInt(int radix) 					将输入的下一个标记扫描为 int 。  
String nextLine() 						将此扫描仪推进到当前行并返回跳过的输入。  
long nextLong() 						将输入的下一个标记扫描为 long 。  
long nextLong(int radix) 				将输入的下一个标记扫描为 long 。  
short nextShort() 						将输入的下一个标记扫描为 short 。  
short nextShort(int radix) 				将输入的下一个标记扫描为 short 。

内部类

定义：在一个类的中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称为内部类。
在成员内部类中可以访问外部类的所有成员。
内部类的对象可以直接访问外部类的成员变量和成员方法。
私有化的内部类不能在外部类以外创建对象，需要在外部类中创建对象。
如果想通过外部类去访问内部类，则需要在外部类中通过外部类对象去创建内部类对象。

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

外部类中创建内部类对象
外部类名.内部类名 对象名 = new 外部类名().new内部类名();
//方式二
外部类名.内部类名 对象名 = new 外部类名().创建内部类对象的成员方法名();


//定义外部类Person
class Person{
	//使用第二种方式时要先定义child成员变量
	//private Child child = null;
	String name;
	int age;
	String height = "100cm";;
		
    public void introduce() {
		System.out.println("姓名 年龄为"+name+age);
		getChildInstance().print();
	}
	//创建一个成员内部类的对象，外部类通过指向这个对象的引用来访问内部类
	private Child getChildInstance() {
        return new Child();
        //使用第二种方式时，上面的方法不能为私有方法
        /*
        if(child == null)
        child = new Child();
        return child;
        */
    }
	
class Child{
	public void print() {
		System.out.println("身高为"+height);
		}
	}	
}

public class Test {
	public static void main(String[] args) {
		Person person = new Person();
		person.name = "张三";
		person.age = 20;
		person.introduce();
		
	//创建内部类Child的对象
		//第一种方式
		Person.Child child = new Person().new Child();
		//第二种方式  当已在外部类中创建了内部类的对象时(不为私有时才可使用)
		//Person.Child child = new Person().getChildInstance;
		child.print();
	}
}

输出结果：
姓名 年龄为张三20
身高为100cm
身高为100cm

静态内部类

定义：被static关键字修饰的成员内部类。
特点：可以在外部类中不创建外部类对象的情况下创建内部类对象。
静态内部类只能访问外部类中的静态成员变量。

外部类名.内部类名 对象名 = new 外部类名.内部类名();

局部(方法)内部类

定义：定义在成员方法内或者一个作用域里面的类。
特点：它只能在当前方法中或者一个作用域里面被使用。
局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。

匿名内部类

匿名内部类适合只需要一次使用的类。
匿名内部类必须继承一个父类或实现一个接口(单继承、单实现)。
匿名内部类不能是抽象类。
由于匿名内部类没有类名，所以不能定义构造器，但可以通过初始化块来完成构造器的工作。

创建接口类型的对象(在方法内创建)
 方式一：	
	new 接口名(){
	实现抽象方法;
		}.抽象方法名();
 方式二：
 接口名 接口对象名 = new 接口名(){
	实现抽象方法;
}
	接口对象名.抽相方法名();


//定义接口
interface Person{
	//定义抽象方法
	public void print();
}

class Child{
	public void test() {
	//方式一
/*		new Person() {
			public void print() {
				System.out.println("匿名内部类创建成功！");
			}
		}.print();*/
	//方式二
		Person person = new Person() {
			
			@Override
			public void print() {
				System.out.println("匿名内部类创建成功！");
			}
		};
		person.print();
	}
}

public class WithoutNameClass {
	public static void main(String[] args) {
		Child child = new Child();
		child.test();
	}
}

继承父类创建匿名内部类
这里的父类也可以是接口实现类(匿名对象)

new 父类名(参数列表){
	类体;
}.类体中的成员方法名();


interface Person{
	public void print();
}

class Child{
	public void test() {
		new Person() {
			public void print() {
				System.out.println("匿名内部类创建成功！");
			}
		}.print();
	}
}
//Son类继承Child类
class Son extends Child{
	public void you() {
	//继承父类创建匿名内部类
		new Child() {
			public void example(){
				System.out.println("继承父类匿名内部类中调用父类方法成功！");
				//调用父类中的test成员方法
				super.test();
				System.out.println("继承父类创建匿名内部类成功！");
			}
		}.example();
	}
}

public class WithoutNameClass {
	public static void main(String[] args) {
		Child child = new Child();
		child.test();
		
		Son son = new Son();
		son.you();
	}
}

输出结果：
匿名内部类创建成功！
继承父类匿名内部类中调用父类方法成功！
匿名内部类创建成功！
继承父类创建匿名内部类成功！