首页 > 编程语言> 文章详细

JAVASE笔记

2022-03-03 16:00:20 阅读：148 来源： 互联网

标签：String int void System 笔记 static JAVASE public

JavaSE

eclipse 使用技巧

当新建eclipse junit测试类时报错可

以试试删掉module-info.java add import应该就是快捷键ctrl+shift+m的操作。 organize imports应该是ctrl+shift+o的操作。 add import导入指定的类。 organize imports导入所有需要导入的类，并且如果有些import是没用的，那么eclipse会自动删除。

成员方法

实例方法的定义

[访问修饰符] 返回类型 方法名称（[参数列表]）{
功能代码...
[return ..]
}

注意：任何显示定义了构造器都将覆盖系统默认提供的公共无参构造器如果想使用无参公共构造器必须重新显示定义

带参数的实例方法的应用

方法的参数

值类型参数：如果参数是值类型，则参数是拷贝实际数据的副本传递，修改参数值实参所存储的原值不会改变。
引用类型参数：如果参数是引用类型，则参数传递的是实际数据的地址引用，修改参数值实参所存储的原值也会改变。

方法的返回值

如果方法中使用了多个return 则必需保证只有一个return被执行，也就是方法只能有一个返回值。

静态方法

静态方法属于类所有，与对象无关，通常不会因为对象不同而改变方法的功能算法，静态方法必须使用static关键字修饰；静态方法也被称为功能函数。
使用方法：类名.方法名（参数列表)
静态方法只能访问静态属性和调用静态方法而不能直接访问实例属性和调用实例方法；this关键字不能出现在静态方法中。

方法重载

使用条件：

在同一个类中
方法名称必须完全相同
参数必需有所不同（个数或者类型不同）

方法重载是面向对象语言多态的特性；体现同名方法完成类似的功能，业务算法却有所不同。
例如：计算不同图形的面积 countarea（参数列表）通过修改参数个数来计算三角形、圆形、长方形等图形的面积。

继承

继承的特性

继承是一个类（父类）到另一个类（子类）的功能延续，体现功能的复用。

一个类可以同时被多个类继承，一父多子
一个类只能有一个直接父类，JAVA不支持多继承
继承具有传递性，祖父 -> 父亲 -> 儿子 -> 孙子
final关键字修饰的类不能被继承
继承语法规则：

[访问修饰符] class 子类名称 extends 父类名称{
}

继承中对象的创建

子类中的super关键字永远指向父类中的构造器

public class computer {
private  String name;
	public double count(double a,double b) {
		return a+b;
	}
	public computer() {
		// TODO Auto-generated constructor stub
	}
	public computer(String name) {
		// TODO Auto-generated constructor stub
		this.name=name;
	}
}

public class watch extends computer{
public watch(String name) {
		super(name); //super() 根据super中的参数决定调用哪个构造器
		// TODO Auto-generated constructor stub
	}

public void display() {
	System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(new Date()) );

}

}

当继承发生时子类默认查找父类中的无参构造器
super关键字必须位于构造器中的第一行（先有父类才能有子类，super前的代码描述的都是子类中的行为。
创建子类对象时总是要先创建一个父类对象，默认子类的构造方法总是要自动调用父类的无参构造方法；永远可以使用子类A构造器构建一个属于父类B的对象（上转型对象 A IS B）；

继承中资源的限制

默认情况下父类的成员属性和方法都可以被子类继承
构造器不能被继承
私有属性和方法无法在子类中直接访问
上转型对象不能访问子类中新添加的属性和方法
final修饰的方法不能在子类中被重写

方法重写

必须满足的条件：

在子类中，方法名称与父类方法名称完全相同
方法的参数个数和类型完全相同，返回类型完全相同。
方法的访问修饰符级别不能低于父类同名方法的访问级别

方法重写的限制：

final修饰的父类方法在子类中不能被重写
static修饰的父类方法在子类中不能被重写，只能覆盖。

package inherit;



public class computer {
private  String name;
	public double count(double a,double b) {
		return a+b;
	}
	
	public computer(String name) {
		// TODO Auto-generated constructor stub
		this.name=name;
	}
	public computer() {
		// TODO Auto-generated constructor stub
	}
public static void staticMethod() {
	System.out.println("我是静态方法，在子类中可以被覆盖但是不能被重写");
}
}


package inherit;


import java.text.SimpleDateFormat;
import java.util.Date;



public class watch extends computer{
//public watch(String name) {
//		super(name);
//		// TODO Auto-generated constructor stub
//	}
	public watch(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	public watch(int x) {
		//super();
		// TODO Auto-generated constructor stub
	}

public void display() {
	System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(new Date()) );

}
/***
 * 
 */
@Override
public double count(double a, double b) {
	// TODO Auto-generated method stub
	return a-b;
}

}


package Test;


import inherit.MobliePhone;
import inherit.computer;
import inherit.watch;



/**
 * 
 * @author 七凉
 *
 */

public class Test {

	public static void main(String[] args) {
	watch w=new watch("联想");
	watch.staticMethod(); // 静态方法可以被覆盖
	}
	
}
//假如在watch.class中添加下面的方法
@Override    
public static void staticMethod() {
	System.out.println("子类不能重写继承的父类静态方法");
}
// 报错，静态方法只能被继承（或者覆盖）不能被重写 
//删除@Override 为覆盖 删除方法为继承

super关键字

super关键字与this关键字都代表对象。super关键字只能在存在继承关系的子类中出现，代表父类对象。

super关键字出现在子类构造器中标识调用父类构造器
super关键字出现在子类方法中标识父类方法或属性
super关键字在子类的实例方法中永远代表父类对象，从而访问父类资源

public static void staticMethod() {
	computer.staticMethod();//静态方法中不能出现super关键字 所以只能用父类访问静态方法
	System.out.println("子类不能重写继承的父类静态方法");
}

抽象类

面向对象编程的核心思想

Java核心编程思想是面向对象！
面向对象核心编程思想是面对抽象！
抽象类的定义：

public abstract class Ainmal{
  public abstract void run();
}

抽象类的特点

抽象类通常应该包括抽象方法，也可以包含非抽象方法
抽象类不能使用final关键字修饰因为final修饰的类不能被继承
抽象类不能够实例化，必须依赖非抽象子类进行创建
抽象类就是用来被继承

抽象类的继承和创建

抽象类被非抽象类继承必须对所有抽象方法提供实现
抽象类被抽象类继承可以不实现父类的抽象方法
抽象类对象的实例化必须通过非抽象子类进行创建
抽象类对象都是上转型对象
final修饰的方法不能在子类中被重写，抽象方法不能用final修饰
//父类Animal

package abstractClassTest;
/**
 * 定义更高层次的抽象组件类，从而可以在被继承时而根据实际子类应用场景继续功能实现
 * 
 * @author 七凉
 *
 */
public abstract class Animal {
   public abstract void run();
   //抽象类中允许定义抽象方法也可以定义非抽象方法
  //修饰符不能是private 
   public abstract void eat();
}

//抽象子类Mammal

package abstractClassTest;
/**
 * 抽象子类可以不实现抽象父类的抽象方法，也可以对抽象方法进行实现
 * @author 七凉
 *
 */
public abstract class Mammal extends Animal {
public abstract void lactation();
//在抽象子类中可以继续添加新的抽象方法，也可以添加非抽象方法
}

//非抽象子类 Lion

package abstractClassTestApp;

import abstractClassTest.Animal;

public class Lion  extends Animal{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("我是狮子，我在草原上奔跑");
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("我是食肉动物");
	}
  
}

//测试子类test

package Test;

import abstractClassTest.Animal;
import abstractClassTest.Mammal;
import abstractClassTestApp.Lion;

public class TestAbstractObjectcreate {
public static void main(String[] args) {
//Animal animal=new Animal();
//抽象类自身不能进行实例化
Animal animal2=new Lion();
//上转型对象 类型是父类 对象是子类

//Animal animal3=new Mammal(); 
//错误 Mammal类不是非抽象子类


}
}

适配器

如何让一个抽象类的非抽象子类有选择性实现父类的抽象方法而不必全部实现所有抽象方法

为抽象类定义适配器类，对所有抽象方法提供空实现
非抽象子类继承适配器类，只重写需要的父类方法
//现在Animal类新增一个hunting方法

package abstractClassTest;
/**
 * 定义更高层次的抽象组件类，从而可以在被继承时而根据实际子类应用场景继续功能实现
 * 
 * @author 七凉
 *
 */
public abstract class Animal {
   public abstract void run();
   //抽象类中允许定义抽象方法也可以定义非抽象方法
  //修饰符不能是private 
   public abstract void eat();
   public abstract void hunting();
}

同时新建一个fish类的非抽象类只想使用run方法而不需要另外两个方法，这个时候就需要为Animal类添加一个适配器这里的添加的适配器类是AnimalAdapter。

package abstractClassTestApp;

import abstractClassTest.Animal;

public class AnimalAdapter extends Animal {
/**
 * 为抽象类提供适配器从而让普通抽象类的子类继承此适配器
 * 避免必需实现所有抽象方法
 */
	@Override
	public void run() {
		// TODO Auto-generated method stub

	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub

	}

	@Override
	public void hunting() {
		// TODO Auto-generated method stub

	}

}

//适配器类实现了所有的抽象方法但是并没有赋予实际的功能这种实现称为空实现

package abstractClassTestApp;

public class Fish extends AnimalAdapter{
@Override
public void run() {
	// TODO Auto-generated method stub
	System.out.println("我是水族，我在水里进行生活");
}
}

通过适配器类就可以根据需要来选择实现哪个方法而不是必需实现所有抽象方法

对象运行时多态

JVM在运行时创建和使用某个对象的时候才能确定对象具体是哪种数据类型

运行时多态能够使设计应用程序更加灵活，易于扩展，代码简洁
运行时多态体现Java面向对象语言特性继承的优越性

package abstractClassTestApp;

import abstractClassTest.Animal;

public class Person {
private String name;
public void raiseLion(Lion lion) {
	System.out.println("养狮子");
	lion.run();
}

public void raiseFish(Fish fish) {
	System.out.println("养鱼");
	fish.run();
}

public void raiseCat(Cat cat) {
	System.out.println("养猫");
	cat.run();
	cat.eat();
}
/**
 * 运行时才决定pet参数是什么对象
 * @param pet
 */
public void raisePet(Animal pet) {
	pet.run();
}
}

package Test;

import abstractClassTest.Animal;
import abstractClassTestApp.AnimalAdapter;
import abstractClassTestApp.Cat;
import abstractClassTestApp.Fish;
import abstractClassTestApp.Lion;
import abstractClassTestApp.Person;

public class TestRuntime {
public static void main(String[] args) {
	Person xiaocui=new Person();
	Animal cat=new Cat();
//	xiaocui.raiseCat(cat);
//根据已经指定好的对象类型传递对象
	Animal lion=new Lion();
	//xiaocui.raiseLion(lion);
	Animal fish=new Fish();
	xiaocui.raisePet(cat);
}
}

接口

接口的作用

Java不支持多继承只能有一个直接父类
Java 允许一个类实现多个接口
Java中的接口就是用来被实现的

接口的定义和对象创建过程

public abstract interface Computer{

public static final int MAX_NUM=1000;
public static final int MIN_NUM=0;
public abstract void count();
public abstract int validate(Object o); 
//接口中属性定义必须是公共、静态的常量
//接口中只允许定义公共的、抽象的方法
}

//接口的创建

public class ComputerImp implements Computer{
public void count(){

}
public int validate(Object obj){
returnn 1;
 }
}

//接口回调：根据实际扩展类来确定调用扩展类中实现的方法，这种过程和现象我们称之为接口回调
测试时所用的computer接口

package Interfaces;

public interface Computer {
/**
 * 
 * java 接口只允许定义公共的静态常量
 * 可以省略public static final修饰符
 */
	public static final int MAX_NUM=Integer.MAX_VALUE;
/**
 * 接口中只允许定义public 的抽象方法 可以省略public 和abstract
 */
	public abstract double count(double a,double b);
}

定义一个工具类实现computer接口的抽象方法

package interfaceimp;

import Interfaces.Computer;

public class Mulity implements Computer {

	@Override
	public double count(double a, double b) {
		
		
		return a*b;
	}

}

** 定义一个测试类**

package test;

import Interfaces.Computer;
import interfaceimp.Mulity;



public class testInterface {
//Computer computer=new Computer();
	//接口不能被实例化
	public static void main(String[] args) {
		Computer computer =new Mulity();
		double res =computer.count(23.5, 32.2);	
		System.out.println(res);
	}


}

Java接口的应用实例

通过java GUI实现两个数的乘法

package interfaceimp;

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;

import Interfaces.Computer;
/**
 * 此类继承了JFrame 并实现了computer接口
 * @author 七凉
 *
 */
public class Mulity extends JFrame  implements  Computer{
   private String title;//窗体标题
   
   private JButton jbutton;
   private JTextField jtf;
   private JTextField jtf2;
   private JTextField jtf3;
   
   private Mulity self;
	@Override
	public double count(double a, double b) {
		
		
		return a*b;
	}
  public Mulity (String title) {
	  init(title);
  }
  private void init(String title) {
	self=this;
	this.setTitle(title);
	this.setVisible(true);
	this.setBounds(200,100,800,600);
	this.setLayout(null);
	jbutton=new JButton("请点击计算");
	jbutton.setBounds(100,100,150,30);
	jbutton.addMouseListener(new MouseListener() {
		
		@Override
		public void mouseReleased(MouseEvent e) {
			// TODO Auto-generated method stub
			
		}
		
		@Override
		public void mousePressed(MouseEvent e) {
			// TODO Auto-generated method stub
			
		}
		
		@Override
		public void mouseExited(MouseEvent e) {
			// TODO Auto-generated method stub
			
		}
		
		@Override
		public void mouseEntered(MouseEvent e) {
			// TODO Auto-generated method stub
			
		}
		
		@Override
		public void mouseClicked(MouseEvent e) {
			// TODO Auto-generated method stub
			double n=Double.valueOf(jtf.getText());
			double m=Double.valueOf(jtf2.getText());
			double res=self.count(n, m);
			jtf3.setText(String.valueOf(res));
			self.validate();
		}
	});
	this.add(jbutton);
	
	jtf=new JTextField();
	jtf.setBounds(100,200,200,30);
	this.add(jtf);
	
	jtf2=new JTextField();
	jtf2.setBounds(100,300,200,30);
	this.add(jtf2);
	
	jtf3=new JTextField();
	jtf3.setBounds(100,400,200,30);
	this.add(jtf3);
	
	this.validate();
 }
}

测试类

package test;

import Interfaces.Computer;
import interfaceimp.Mulity;



public class testInterface {
//Computer computer=new Computer();
	//接口不能被实例化
	public static void main(String[] args) {
		Computer computer =new Mulity("java窗体");
		double res =computer.count(23.5, 32.2);	
		System.out.println(res);
	}


}

接口的继承

Java 规定接口只能由其他接口继承(也就是说类和接口只能是实现关系)
子接口继承的目的在于拥有父接口功能后添加新的抽象定义（添加新的抽象方法定义或者属性）
一个普通类实现接口时必须同时实现其父接口的抽象方法（实现子类的同时父接口也会被实现）
接口被实现目的就是实现业务功能具体化

内部类

内部类的作用

内部类通过外部类访问从而被限定使用权限
内部类所定义功能更多时候只为外部类提供
内部类让某些功能更加安全

内部类的定义和创建

内部类必须定义在某个类中，所在类为其外部类
内部类可使用public，protected，private访问修饰符
内部类可使用abstract，final，static修饰符
内部类没有单独的Java源文件，只有class文件（内部类的类文件名称规范：外部类$内部类名.class）

Computer.Cpu cpu=new Computer().new Cpu();
//创建普通内部类
Computer.Cpu cpu=new Computer.Cpu();
//创建静态内部类

//测试静态内部类和普通内部类的创建

package imp;



import interfaces.Computer;

public class NoteBookComputer implements Computer {

	@Override
	public void useComputer(double num0,double num2) {
	Hoard hoard =new  NoteBookComputer.Hoard();
//创建了一个本地的静态内部类对象
	hoard.displayInfo();
	}
public class Cpu{
	public void handleDate() {
		System.out.println("我是处理器 我可以很快的处理业务数据");
	}
 }
/**
 * 私有的静态内部类
 * @author 七凉
 *
 */
private static class Hoard{ 
	public void displayInfo() {
		System.out.println("我是主板我的作用很重要");
	}
}
}

package interfaces;

public interface Computer {
	
void useComputer(double a,double b);
}

package test;

import imp.NoteBookComputer;
import imp.NoteBookComputer.Cpu;

public class TestinnerClass {
public static void main(String[] args) {
	Cpu cpu=null; //外部类内部类引用
	NoteBookComputer notebook=new NoteBookComputer();
	cpu=notebook.new Cpu();
	cpu.handleDate();
	
 }
}

局部类的应用

package imp;



import interfaces.Computer;

public class NoteBookComputer implements Computer {
   //局部类应用
	@Override
	public void useComputer(double num0,double num2) {
	class Memory{
	public void store(double a,double b) {
		System.out.println("已经计算完成，数据结果已经存储"+(num0+num2));
	 }
	
	}
		
	Memory 	memory =new Memory();
	//创建局部类对象
	memory.store(num0, num2);
		Hoard hoard =new  NoteBookComputer.Hoard();	
//创建了一个本地的静态内部类对象
	hoard.displayInfo();
	}
public class Cpu{
	public void handleDate() {
		System.out.println("我是处理器 我可以很快的处理业务数据");
	}
 }
/**
 * 私有的静态内部类
 * @author 七凉
 *
 */
private static class Hoard{ 
	public void displayInfo() {
		System.out.println("我是主板我的作用很重要");
	}
}
}

//测试匿名内部类

package test;

import imp.NoteBookComputer;
import imp.NoteBookComputer.Cpu;

public class TestinnerClass {
public static void main(String[] args) {
	Cpu cpu=null; //外部类内部类引用
	NoteBookComputer notebook=new NoteBookComputer();
	cpu=notebook.new Cpu();
	cpu.handleDate();
	notebook.useComputer(6, 5);
 }
}

匿名类对象应用

匿名类对象就是没有名称的对象
匿名类对象经常作为接口或抽象类的实现
匿名类对象可减少接口或抽象类实现类的定义
匿名类对象一定属于它实现的父级类型
//测试匿名类

package xzit;

import interfaces.Computer;

public class staff {

	public void useComputerWorking(Computer computer,double n,double m) {
		computer.useComputer(n, m);
	}
}
//因为接口不能被实例化 通过匿名类重写接口内的方法

package test;
import interfaces.Computer;
import xzit.staff;
public class TestHiddenClassNameObject {

	public static void main(String[] args) {
		staff mark=new staff();
		double a=23.5;
		double b=45.7;
		mark.useComputerWorking(new Computer() {
			
			@Override
			public void useComputer(double a, double b) {
				// TODO Auto-generated method stub
				double res=a+b;
				System.out.println("利用计算机计算完成，结果是"+res);
			}
		}, a, b);
	}
}

静态块

静态代码块的内容

静态代码块中允许访问静态属性
静态代码块中允许调用静态方法
静态代码块中允许定义局部变量及常量
静态代码块中允许定义局部类
静态代码块中不能访问实例属性和方法以及定义方法
静态代码块和类一样只会被加载一次然后就驻留在内存中再使用类访问任何类属性或者调用类方法时它的静态代码块都不会被执行

package xzit;
/**
 * 静态块
 * @author 七凉
 *
 */
public class Location {

	public static final int EAST;
	public static final int WEST;
	public static final int SOUTH;
	public static final int NORTH;
	static {
	EAST=0;	
	WEST=1;
	SOUTH=2;
	NORTH=3;
	displayLocation();
	}
	public static void displayLocation() {
		System.out.println("您的当前默认位置是"+NORTH);
	}
}

测试代码块

package test;

import xzit.Location;

public class TestStaticBlock {

	public static void main(String[] args) {
	int location=Location.SOUTH;
	
	int location2=Location.EAST;
	//虽然被调用两次 但是只会显示第一次的内容
	}
}

静态块的内容限制

package xzit;



/**
 * 静态块
 * @author 七凉
 *
 */
public class Location {

	public static final int EAST;
	public static final int WEST;
	public static final int SOUTH;
	public static final int NORTH;
	public static double distance;
	static {
	EAST=0;	
	WEST=1;
	SOUTH=2;
	NORTH=3;
	displayLocation();
	//displayDistance(distance);
	//静态块中不允许访问非静态字段以及非静态方法
	
	//可以定义在static块中使用的内部类（局部类）
	class B{
		
	}
	
	}
	public static void displayLocation() {
		System.out.println("您的当前默认位置是"+NORTH);
	}
	private   void displayDistance(double distance) {
		
	}
}

静态代码块的加载

静态代码块属于类和对象无关，随着类的加载而加载
静态代码块在静态属性初始化后与调用构造器之前加载
静态代码块在加载时通常做一些静态属性或常量赋值，调用静态方法等工作，如果想在产生任何所在类对象之前类加载时处理类信息则可选择使用静态代码块完成
//测试代码块在对象创建前调用
//在Location添加一个有参构造器

public Location(double distance) {
		this.distance=distance;
		System.out.println("调用构造器创建对象");
	}

//在测试类中显示调用有参构造器创建对象

package test;

import xzit.Location;

public class TestStaticBlockLoad {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
   Location location=new Location(312.2);
	}

}

输出结果：

您的当前默认位置是3
调用构造器创建对象

Object类应用

创建Object类

public Object(){
}
Object 提供唯一的构造器创建Object类型实例

Java任何引用类型对象都可以赋值给Object类型变量

toString方法

toSting方法返回Object对象的字符串表示形式
此方法可以在任何类中进行重写，重写后将得到一个新的字符串返回形式

equal方法

public final native Class<?>getClass();
//此方法是个终极本地方法，不允许子类进行重写

重写equals方法

package Entity;

public class Employee {
private String id;
private  String name;
public String getId() {
	return id;
}
public void setId(String id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public Employee(String id, String name) {
	super();
	this.id = id;
	this.name = name;
}
public Employee() {
	super();

}
@Override
 public boolean equals(Object obj) {
 
	Employee employee=(Employee)obj;
	return this.getId().equals(employee.getId())?true:false;
}

}

测试代码

package test;



import Entity.Employee;

public class Test3 {
public static void main(String[] args) {
	Employee emp0=new Employee("emp009","任盈盈");
	
	Employee emp2= new Employee("emp009","令狐冲");
   
	boolean bool=emp0.equals(emp2);
	
	System.out.println(bool?"2个对象ID值是相同的":"2个对象ID值是不相同的");
}
}

getClass方法

getClass方法返回当前对象的运行时类(Class)对象
测试代码

package test;

import Entity.Employee;

public class Test4 {
public static void main(String[] args) {
	Employee emp0=new Employee("emp009","令狐冲");
	Class empClass=emp0.getClass();
  //使用Class对象获取当前对象的类的完全限定名称
	System.out.println("类名称是："+empClass.getName());
}
}

hashCode方法

返回该对象的int类型哈希码值

public native int hashCode();
//此方法为提高哈希表的性能而支持，通常在非特殊情况下不必重写此方法
//不能用equals方法来判断对象hashCode值是否相等 因为如果equals 被重写了会出现问题

测试代码

package test;



import Entity.Users;

public class Test5 {
 public static void main(String[] args) {
  
	 Users u0=new Users("NO0001","东方不败",32);
	 Users u2=u0;
	 System.out.println(u0==u2);
	 
	 System.out.println(u0.hashCode());
	 System.out.println(u2.hashCode());
	 System.out.println(new Users().hashCode());
}
}

clone方法

protected native Object clone() throws CloneNotSupportedException;
//被克隆的对象与当前对象不具有同一个引用，但是具有完全相同的对象属性，欲克隆当前对象则当前对象所属类应是实现Cloneable接口

Integer包装类

Java基本数据类型4型8种都对应有一个包装类
byte——Byte
short——Short
int——Int
long——Long
float——Float
double——Double
char——Character
boolean——Boolean

Integer类的作用

     Integer类对基本数据类型int的进行包装，它包含一个int值。
     Integer类提供了多个方法，能在int类型和String类型之间相互转换，还提供了处理int类型时非常有用的其他一些常量和方法。
     定义类成员属性经常使用Integer替代int从而可以应用更多integer的功能

Integer对象的创建

默认构造器

public Integer(int value);

public Integer(String str);

测试代码

package domain;

public final class Employee {
private Integer id;

public Employee(Integer id) {

	this.id = id;
}

public Integer getId() { //返回的是Integer
	return id;
}

public void setId(Integer id) {
	this.id = id;
}

public Employee() {

}

}

package test;

import domain.Employee;

public  class TestInteger {

public static void main(String[] args) {
	Employee emp=new Employee();
    Employee emp2=new Employee();
    Integer intObj=new Integer(24);
    //java jdk1.9开始不建议用integer构建包了
  Integer intobj1=Integer.valueOf(25);  
	emp.setId(intObj);
	System.out.println(emp.getId());
	
	emp2.setId(new Integer("35"));
	//jdk1.9之后不建议采用new Integer构建对象
    //会警告 但是不影响程序运行
	emp2.setId(Integer.valueOf("36"));
	System.out.println(emp2.getId());
}
}

Integer常用属性和方法

Integer字段常量

public static final int MAX_VALUE
//int类型能够表示的最大值
//2147483647
public static final int MIN_VALUE
//int类型能够表示的最小值
//-2147483648
public static final int SIZE
//二进制补码表示int值的比特位数
//32
public static final int BYTES
//int类型在JVM中占有空间的字节数
//4

compareTo方法

public int compareTO(Integer target)
//如果当前Integer对象所包含的int值大于target包含的值则返回1，如果小于返回-1，如果相等则返回0

intValue方法

public int intValue();
//以int类型返回该Integer的值。实现从对象类型转换为值类型，其他类似方法：
byteValue():shortValue();longValue();
floatValue();doubleValue();

parseInt方法

public static parseInt(String s)
//将给定的字符串s转换为10进制int值类型返回
//s字符串除了第一个字符可以使用-表示有符号的复数以外
//其他字符都必需保证是0~9的数字，否则转换出现NumberFormatException

测试代码块

//parseInt 静态方法 将字符串转换为值类型，所有的包装类都具此类似的方法
	String pwd="231120";
	int pwdInt=Integer.parseInt(pwd);
	System.out.println(pwdInt+9);
	//parseInt 重载
	System.out.println("二进制"+Integer.parseInt("1010", 2));
	System.out.println("二进制"+Integer.parseInt("777", 8));
	System.out.println("二进制"+Integer.parseInt("FFAB", 16));

toBinaryString方法

public static String toBinaryString(int i)

将给定的int类型参数i转换为二进制字符串形式返回。
返回的字符串形式省略前导0，类似方法：
toOctalString 转换为8进制字符串
toHexString 转换为16进制字符串

valueOf方法

public static Integer valueOf(int i)

返回一个表示指定的int值的Integer实例。如果不需要新的Integer实例，则通常应优先使用该方法从而提供JVM效率及节省资源。类似方法：

public static Integer valueOf(String s)
public static Integer valueOf(String s,int radix)

package test;

public class TestValueOfMethod {
 public static void main(String[] args) {
	int num=1234;
	Integer intObj0=Integer.valueOf(num);
	System.out.println(intObj0.intValue());
	System.out.println(Integer.valueOf("345").intValue());
	String str="1011010";
	Integer intObj2=Integer.valueOf(str,2);
	System.out.println(intObj2);
	Integer intObj3=Integer.valueOf(str,8);
	System.out.println(intObj3);
	Integer intObj4=Integer.valueOf(str,16);
	System.out.println(intObj4);
}
}
//运行结果：1234
//345
//90
//266760
//16846864

tsoString方法

测试代码

package test;



public class TestToStringMethod {
	public static void main(String[] args) {
		Integer intObj=Integer.valueOf(187);
		System.out.println(intObj.toString().length());
		//指向实例方法 不带参数的tostring方法
		
		System.out.println(Integer.toString(2));
		//指向静态方法 带参数的tostring方法
		//静态tostring重载方法
		System.out.println(Integer.toString(intObj, 2));
		System.out.println(Integer.toString(intObj, 8));
		System.out.println(Integer.toString(intObj, 16));
		System.out.println(Integer.toString(intObj, 27));
		System.out.println(Integer.toString(intObj, 4));
	}

}
//输出结果
//3
//2
//10111011
//273
//bb
//6p
//2323

Character包装类

Character实例的创建

Character类提供了唯一定义char参数类型的构造方法

public Character(char value)
//静态方式获取Character实例引用
public static Character valueOf(char c)

测试代码

package test;

public class Test {

public static void main(String[] args) {
	Character charobj=new Character('A');
	Character charobj1=Character.valueOf('a');
	//jdk9 之后不建议使用new Character方式
	//构造Character对象 可以使用valueOf方法
}
}

Character实例方法

public char charValue() 返回此Character对象的char值
public int compareTo（Character get）比较大小
public String toString（）返回此对象包含char值的字符形式

Character静态方法

public static boolean isDdefined(int ch)
是否是被定义为Unicode中的字符（0-56533）
public static boolean isDigit（int ch）
是否为数字
public static boolean isLetter（int ch）
是否为字母
public static boolean isLetterOrDight(int ch)
是否为字母或者数字
public static boolean isLowerCase（int ch）
是否为小写字母
public static boolean isSpaceChar(int ch)
是否是空格，废弃的方法
public static boolean isUpperCase(int ch)
是否是大写字母
public static boolean isWhiteSpace(int ch)
是否为空格（推荐）
public static int toLowerCase(int ch)
返回转换为小写的字符
public static int toUpperCase(int ch)
返回转换为大写的字符

Sytstem类

System类概述
System表示当前运行的JVM，System提供了标准输入、标准输出和错误输出流对象。
对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法，以及获取系统时间和显示告知垃圾回收器回收垃圾释放内存空间的方法。
System是只读的不能被实例化
System实用方法
获取输入，输出流：
System.out获取标准输出流
System.in获取标准输入流
System.err获取错误输出流
-System实用方法2
public static void exit(int status)
//退出系统
public static void gc()
//通知垃圾回收系统期望快速回收垃圾以释放内存空间
public static long currentTimeMillis()
//获取当前系统时间毫秒表示
public static Properties getProperties()
//获取当前系统属性map集合
public static String getProperty(String key)
//按照给定的名称获取当前系统属性字符串表示
public static native void arraycopy(
Object src,int srcPos,
Object dest,int destPos,int length)
//复制数组

public static Map <String,String >getenv()
//获取当前JVM所在本地系统信息视图

TestSystemClass.java

package test;



public class TestSystemClass {
	 public static void main(String[] args) {
	User[] userList=new User[100000];
	long begin =System.currentTimeMillis();
	for(int i=0;i< 10000;i++) {
		userList[i]=new User("用户"+i);
		
	}
	long end=System.currentTimeMillis();
	System.out.println("存储10000个User对象用时"+(end-begin)+"毫秒");
	}
}

TestSystemClass2.java

package test;

import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class TestSystemClass2 {
	  public static void main(String[] args) {
		  Properties pros=System.getProperties();
		 // System.out.println(pros.toString());
   //拷贝数组
		  int[] srcs= {0,1,2,3,4,5,6,7};
		  int[] dest=new int[srcs.length-2];
		 
		  System.arraycopy(srcs, 1, dest, 0, dest.length);
		  for(int x:dest) {
			  System.err.print(x+" ");
		}
		  
   //利用system获取本地计算机信息
		 Map<String,String> mapsMap=System.getenv();
    Set<String> keys=mapsMap.keySet(); 
    for(String name:keys) {
        System.out.println(name+" = " +mapsMap.get(name));	
     }
	}



}

Math类

Math类定义了数学运算的基本功能，Math类中所有属性及功能方法都定义为static的，Math类不需要创建实例，Math类是final修饰的终极类，不能被继承。

Math类常量属性

Math类常量字段

public static final double E
自然对数的底数，通常用于科学领域的计算使用
public static final double PI
圆的周长和直径的比，即圆周率表示值（3.141592653589793）

Math类常用方法

public static double abs(double | float | long |int num)
**绝对值**

public static double cbrt(double num)
**立方根**

public static double ceil(double num)
**返回最小的（最接近负无穷大）double值，该值大于等于参数，并等于某个整数**

public static double floor（double a）
**返回最大的（最接近正无穷大）double值，该值小于等于参数，并等于某个整数**

public static double max(double a,double b)
public static double min(double a,double b)
public static double pow(double a,double b)
//返回a的b次幂浮点值
public static double random()
//返回非符号的double值,此值大于等于0.0且小于1.0的

String类

string对象的创建

//	  public  String()
//    public String(byte[] bytes)
//    public String(char[] chars)
//    public String(char[] chars,int offset,int count)
//    public String(String str)
//    public String(StringBuffer buffer)

String类常用方法

public String[] split(String regex)
public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)
public char[] toCharArray()
//将字符串转换为char型数组的tocharArray
public String toLowerCase()
public String toUpperCase()

public String replace(char oldChar,char newChar)
public String replace(String target,String newStr)
//字符串替换字符串
public static String valueOf(Object obj)

构建StringBuilder实例

StringBuilder和StringBuffer都是可变（自身字符序列可被修改）的字符序列
StringBuilder是非线程安全的
StringBuffer是线程安全的
涉及线程安全情况下通常选择StringBuffer
StringBuilder的执行效率比StringBuffer更高

StringBuilder对象的创建

public StringBuilder()
public StringBuilder(int capacity)
//初始容量  StringBuilder可以被修改
public StringBuilder(String str)
public StringBuilder(CharSequence seq)
//charSequence 字符序列

StringBuilder常用方法

public StringBuilder append(Object obj)
public StringBuilder delete(int start,int end)
public StringBuilder deleteCharAt(int index)
public StringBuilder insert(int offset,Object obj)
public StringBuilder replace(int start,int end,String str)

public StringBuilder reverse()
public void setLengeth(int newLength)
public void setCharAt(int index,char ch)

Date类

Date对象的创建

public Date()
//构建一个JVM所在环境的系统日期Date对象
public Date(long date)
//以给定的date参数构建一个Date对象

Date未废弃方法以及格式化

public boolean after(Date when)
public boolean before(Date when)
public int compareTo(Date anotherDate)
public long getTime()
public void setTime(long time)
public String toString()
//dow mon dd hh:mm:ss zzz yyyy

格式化日期对象

使用DateFormat抽象类对Date对象进行格式化

DateFormat.getDateInstance()
//获取DateFormat实例

format(Date)方法实现对给定日期对象的格式化并返回字符串表示形式
SimpleDateFormat继承自DateFormat类，可提供自定义格式的转换规则

SimpleDateFormat类

public SimpleDateFormat()
//以默认(yy/M/dd ah:m)的模式和语言环境的日期格式构造对象
public SimpleDateFormat(String pattern)
//以给定的pattern模式和默认语言环境的日期格式构造对象
public SimpleDateFormat(String pattern,Locale locale)
//以给定的pattern模式和locale语言环境的日期格式构造对象
//SimpleDateFormat sdf2=new SimpleDateFormat("yyy-MM-dd a",Locale.ENGLISH);

常用方法

public String format(Date date)
//格式化Date对象为字符串方法
public Date parse(String dateStr)
//格式化字符串为Date对象方法

在这里插入图片描述

Calendar类

Calendar日历类的创建

Calendar类模仿日历功能，Calendar与Date没有任何继承关系，它们不能相互转换；Calendar提供了对日期时间操作更灵活的方法支持，可以从Calendar获取与之相对应的Date对象，反之则不可以；SimpleDateFormat不能提供对Calendar的转换支持

public static Calendar getInstance()
public static Calendar getInstance(Locale aLocale)

public void testCreateCalendar() {
		
		Calendar cal=Calendar.getInstance();
		//获取与当前系统平台相关的默认日历对象
		System.out.println("当前是"+cal.get(Calendar.YEAR)+"年"+cal.get(Calendar.MONTH)+"月"+
		cal.get(Calendar.DATE)+"日");
		
	Calendar cal2=Calendar.getInstance(Locale.ENGLISH);
	
	Date engDate=cal2.getTime();
	//获取Date对象
	System.out.println(new SimpleDateFormat("yyyy-MM-dd a hh:mm:ss",Locale.ENGLISH).format(engDate));
	
	}

Calendar主要常量字段

public static final int AM
//指示从午夜到中午这段时间的AM_PM字段值(0)
public static final int PM
//指示从中午到午夜这段时间的AM_PM字段值(1)
public static final int AM_PM
//指示从当前日历获取AM_PM对应的AM或PM值(0或1)
public static final int YEAR
//日历中的年份
public static final int MONTH
//日历中当年的月份,0-11(实际应该+1)
public static final int DATE
//日历中当月的天 1-31
public static final int HOUR
//日历12小时制表示0-11
public static final int HOUR_OF_DAY
//日历24小时制表示(0-23)
public static final int MINUTE
//指示一小时中的分钟(0-59)
public static final int SECOND
//指示一分钟的秒(0-59)
public static final int MILLISECOND
//指示一秒钟的毫秒(0-999)
public static final int WEEK_OF_MONTH
//日历中当月第几周(1-4)
public static final int WEEK_OF_YEAR
//日历中当前第几周(1-54)

Calendar主要方法

public abstract void add(int field,int value)
//**更改日历中某个字段的值
public boolean after(Object when)
//判断日历当前时间是否在给定的时间之后
public boolean before(Object when)
//判断日历当前时间是否在给定的时间之前
public int compareTO(Calendar anotherCalendar)
//比较两个Calendar的时间值从历元至现在的毫秒差

public final Date getTime()
//**获取日历当前日期时间对象(java.util.Date)
public void set(int field,int value)
//将给定的日历字段field设置为给定value
public final void set(int year,int month,int date)
//设置日历的年份、月份、日期值
public final void set(int year,int month,int date,int hourOfDay,int minute,int second)
//设置日历的年、月、日、时、分、秒的值

List类

List集合接口规范概述

List接口继承自——Collection——Iterable
Iterable接口循环迭代方式访问集合中的数据元素，定义了唯一一个返回指向集合的Iteratior迭代器。它主要通过foreach方式处理集合中的元素，任何其实现类都可以通过获取指向集合的迭代实现对集合的遍历。
List接口间接继承自Iterable接口并在Collection直接父接口基础上定义更多的可操作方法，最典型就是定义了以索引方式操作集合元素的方法。

List集合接口常用方法

boolean add(Object e)

void add(int index,Object element)

void clear()

boolean contains(Object o)

Object get(int index)

int size()

void clear()

boolean contains(Object o)

ArrayList集合实现类

ArrayList集合类是List接口的大小可变数组的实现。实现类所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部来存储列表的数组的大小。（此类大致上等同与Vector类，除了此类是不同步的）。ArrayList查找访问集合元素速度比较快，删除，插入随机操作比较慢，经常在企业及开发中使用ArrayList处理数据应用。

Vector 集合实现类

Vector也被称为向量集合，和ArrayList非常类似都是可变的动态数组集合，最大的区别时Vector是线程同步的，相对ArrayList数据处理效率要低；在多线程中通常使用Vector处理可能被多个线程并发访问的数据。
Vector集合具有ArrayList的所有方法外，增加了public Enumeration<E> element()此方法返回Enumeration枚举接口,可使用此接口实现对集合的变量

Set接口

Set集合接口规范概述

继承自——Collection——Iterable
Iterable接口循环迭代方式访问集合中的数据元素，定义了唯一一个返回指向集合的Iterator迭代器。它主要通过for each方式处理集合中的元素，任何其实现类都可以通过获取指向集合的迭代实现对集合的遍历
Set接口只能存储不相等的对象，Set接口是数学Set的抽象描述，与ArrayList不同，它其中元素不带有任何索引，不能使用索引方式访问集合中元素。
Set接口通常追加，遍历元素比较慢，随机删除修改数据速度稍快。

Set常用方法规范

boolean add(Object e)
void clear()
boolean contains(Object o)
Iterator<E> iterator()
boolean remove(Object o)
int size()
boolean isEmpty()
Object[] toArray()

HashSet集合实现类

此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持实现算法。HashSet不能保证set集合元素的迭代顺序，也不能保证该顺序恒久不变。
HashMap允许使用null元素
HashSet实现不是线程同步的。如果在多个线程同时访问一个HashSet，应该做必要额外同步处理，HashSet由于不排序，通常只需效率比较高

Map接口

Map集合接口规范概述

Map接口是存储键值对象的顶级集合接口。存储在Mao集合中的键值对象必须确保每个键是不重复的的；对与相同的键对象在添加到Map中时会产生覆盖源键值对象操作。
在通常情况下Map通过一个唯一的键查找其对应的值对象，键和值必须同时成对出现，一个键对应一个值对象。
在很多情况下可以使用Map对象替代（如果需要）实体对象，这样可以在应用程序实体类比较多的情况下减少类的定义。

Map集合接口常用方法

Object put(Object key,Object value)
Obeject get(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()

Set<K> keySet()
//获取所有键的集合
Collection<V> values()
booleans isEmpty()
V remove(Object key)
//移除键值对
void clean

HashMap集合实现类

Hash是继承AbstractMap间接实现Map接口的基于哈希表算法的Map接口的实现类。此实现提供所有可选的映射操作，允许使用null值和null键。HashMap不保证印映射的顺序，特别是它不保证该顺序恒久不变。
HashMap不是线程安全的，如果在多线程中使用必需在程序中处理同步问题

public HashMap()
//构造一个具有默认初始容量（16）和默认加载因子（0.75）的空HashMap
public HashMap(int initSize)
//构造一个指定初始容量和默认加载因子的空HashMap
public HashMap(int initSize,float loadFactor)
//构造一个带指定初始容量和加载因子的空格HashMap

Hashtable集合实现类

Hashtable 类实现一个哈希表，该哈希表将键映射到相应的值。任何非null对象都可以用作键或值
Hashtable与HashMap功能几乎是相同的，最大区别在于HashMap是非线程同步的，而Hash table是线程同步的，在多线程中通常使用同步的Hashtable。
由于Hashtable要考虑线程同步问题，因此Hashtable执行效率要比HashMap低。在非多线程中提倡使用HashMap存储键值对象，从而提供性能。

泛型

泛型概述

泛型在Java中被称之为Java类型，简称GJ，（Java垃圾回收器 GC）泛型是Java SE平台1.5版本增加的新特性。泛型在Java中不是一种数据类型，是一种在编译时期的特殊语法，它能够让JVM识别从而确定在应用泛型的操作中体现泛型特点，帮助程序员阿紫开发中从泛型中获得更高效和更安全数据的管理操作。
泛型由于不是一种Java的数据类型所有在运行时，JVM将使用擦除法将泛型描述还原成未应用泛型语法的规则进行执行
泛型基本语法<T>
使用泛型的好处:

泛型能够在代码书写过程中帮助程序员提高效率和数据类型安全
泛型能够在编译阶段确定数据类型师傅符合要求，规避错误发生。
泛型能够避免数据对象强制类型转换操作
泛型也能够支持在动态下确定数据类型

List集合中应用泛型

void test() {
		List<Car> carList=new ArrayList();
		//List应用泛型规避存储范围避免低级错误
		carList.add(new Car("233123-23","北京市","白色"));
		carList.add(new Car("233123-23","上海市","红色"));
		carList.add(new Car("233123-23","辽阳市","黑色"));
		carList.add(new Car("233123-23","长沙市","蓝色"));
		
		//carList.add(new File(""));
		//对不符合泛型规定的类型存储将在编译时报错
		for(Car car:carList) {
			System.out.println(car.getCarNumber()+"\t"+car.getColor());
		}
	}

Map集合中应用泛型

void testUserGJINSetAndMap() {
		Set<Map<String,Object>> carSet=new HashSet();
		Map<String,Object> car0=new HashMap();
		car0.put("number", "湘A-201314");
		car0.put("color", "白色");
		car0.put("maxyear", 15);
		
		Map<String,Object> car2=new HashMap();
		car2.put("number", "粤A-202120");
		car2.put("color", "黑色");
		car2.put("maxyear", 16);
		
		Map<String,Object> car3=new HashMap();
		car3.put("number", "江A-20220302");
		car3.put("color", "蓝色");
		car3.put("maxyear", 10);
		
		
		carSet.add(car3);
		carSet.add(car2);
		carSet.add(car0);
		
		for(Map<String,Object> car:carSet) {
			System.out.println(car.get("number").toString()+"\t"+car.get("color").toString()+"\t"+
		car.get("maxyear").toString());
		}
	}

带泛型的类

public class GJClass<T>{
	public String getClassName(T t){
	return t.getClass().getName
	}
}

测试用例

void testGetClassName() {
		AggregateSupporter<Car> carAs=new AggregateSupporter<>();
		Car car=new Car();
		System.out.println(carAs.getClassName(car));
		
		AggregateSupporter<ship> shipAs=new AggregateSupporter<>();
		ship Iship=new ship();
		System.err.println(shipAs.getClassName(Iship));
	}

带泛型的接口

public interface CountManger<T>{
 Double ount(T countSupport,Double r);
 Double count(T countSupport,Double bottom,Double height)
 }

class CountMangerChinaImp implements 
	CountManger<ComputerChina>{}
class CountMangerUsaImp implements
	CountManger<ComputerUsa>{}

泛型无界通配符

List<integer> intList =new ArrayList<integer>();
List<Number>numList =initList;
//错误

//解决方案
List<?> numberList =new ArrayList<>();
numberList =intList;
numberList =new ArrayList<Number>();
numberList =new ArrayList<String>();

通配符限界

<?> 无界通配符，占位符？通常会被处理为Object

1.当前方法中借以Object超类中的方法来实现功能时；
2.使用泛型类中不依赖于类型参数的方法时。

<? extends Type>上限通配符,？满足是Type或是其子类 1.集合类型存在继承关系; 2.限制类型的上线标准，无下限。 <? super Type>下限通配符，？满足是Type的直接或简介超类型 1.集合类型存在继承关系； 2.限制类型的下限标准,无上限。提示：泛型通配符几乎从不会用在泛型的方法操作，对象的创建，如果集合应用泛型通配符，通常也不会调用集合相关方法插入集合元素等依赖于类型的操作；泛型通配符经常用在方法入参，方法返回值（尽量避免）成员属性字段及表示在类上，但在使用中应该遵循上述规定

标签：String,int,void,System,笔记,static,JAVASE,public
来源： https://blog.csdn.net/qq_54743738/article/details/121149498

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

JAVASE笔记

JavaSE

eclipse 使用技巧

当新建eclipse junit测试类时报错 可

以试试删掉module-info.java add import应该就是快捷键ctrl+shift+m的操作。 organize imports应该是ctrl+shift+o的操作。 add import导入指定的类。 organize imports导入所有需要导入的类，并且如果有些import是没用的，那么eclipse会自动删除。

成员方法

实例方法的定义

带参数的实例方法的应用

方法的参数

方法的返回值

静态方法

方法重载

使用条件：

继承

继承的特性

继承中对象的创建

继承中资源的限制

方法重写

必须满足的条件：

方法重写的限制：

super关键字

抽象类

面向对象编程的核心思想

抽象类的特点

抽象类的继承和创建

适配器

对象运行时多态

接口

接口的作用

接口的定义和对象创建过程

Java接口的应用实例

接口的继承

内部类

内部类的作用

内部类的定义和创建

局部类的应用

匿名类对象应用

静态块

静态代码块的内容

静态块的内容限制

静态代码块的加载

Object类应用

toString方法

equal方法

getClass方法

hashCode方法

clone方法

Integer包装类

Integer类的作用

Integer对象的创建

Integer常用属性和方法

Integer字段常量

compareTo方法

intValue方法

parseInt方法

toBinaryString方法

valueOf方法

tsoString方法

Character包装类

Character实例的创建

Character实例方法

Character静态方法

Sytstem类

Math类

Math类常量属性

Math类常量字段

Math类常用方法

String类

string对象的创建

String类常用方法

构建StringBuilder实例

StringBuilder对象的创建

StringBuilder常用方法

Date类

Date对象的创建

Date未废弃方法以及格式化

格式化日期对象

SimpleDateFormat类

Calendar类

当新建eclipse junit测试类时报错可