常用类

一、数组类

1）可变参数

参数的个数可以有可以没有,可以有1个,可以有多个

数据类型 … 变量名 -->定义在参数列表的最后面

public class Para02 {

	public static void main(String[] args) {
		getSum(1,2,3,4,5);
		test("haha","hehe",1);
	}
	
	//求多个整数的和  ...代表可变参数
	//至少传一个参数
	public static void getSum(int x,int ... i){
		int sum=0;
		for(int a:i){
			sum+=a;
		}
		System.out.println("和为"+sum);
	}
	
	//报错  可变参数得在参数列表最后面
	public static void getSum(int ... i,int x){}
	
	//对象类型的可变参数
	public static void test(Object ... arr){  //多态
		for(Object s:arr){
			System.out.println(s);
		}
	}
}

2）Arrays工具类

常见的有：

• static boolean equals(int[] a, int[] a2)如果两个指定的 int 型数组彼此相等，则返回 true。
• static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定数组彼此是深层相等 的，则返回 true。
• static String toString(int[] a) 返回指定数组内容的字符串表示形式。
• static int[] copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到一个新数组。

注：详见API手册

二、内部类

分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

1)成员内部类

内部类定义在外部类的成员位置,可以使用成员修饰符来修饰,具有成员的特性

注：

• 成员内部类中不能定义静态的内容,除了静态的常量
• 外部类中可以通过内部类对象使用内部类中的成员(内部类私有的属性也可以用)

• public class Outer01 {
  	private String name="因为";
  	int a=15;
  	//内部类
  	class Inner{
  		static final int age=5;
  		int a=10;
  		private int b=3;
  		
  		public void inner(){
  			int a=5;
  			System.out.println("我是内部类中的成员方法");
  			
  			//区分外部类,内部类,局部的同名变量
  			System.out.println(a);  //局部
  			System.out.println(this.a);  //内部类
  			System.out.println(Outer01.this.a);  //外部类
  		}
  	}
  	
  	public void outter(){
  		System.out.println("我是外部类中的成员方法");
  		Inner in=new Inner();
  		System.out.println(in.b);
  	}
  }
  

  2)静态内部类

  使用方法：

  • 只能在静态内部类中定义静态的内容,除了静态常量
  • 静态内部类中使用外部类中的成员内容,必须通过外部类对象,因为内部类是静态的,静态内容中不能直接使用非静态的内容
  • 外部类中可以直接通过内部类类名使用内部类中静态的内容,必须通过静态内部类的对象使用成员

  public class Outer03 {
  	private static int a=5;
  	private int b=10;
  	
  	//静态内部类
  	static class Inner{
  		static String name="卢双双";
  		String gender="女";
  		
  		static void haha(){
  			System.out.println(a);
  			System.out.println(new Outer03().b);
  			System.out.println(name);
  			System.out.println(new Inner().gender);
  			System.out.println("静态内部类中的静态方法");
  		}
  		
  		void hehe(){
  			System.out.println(name);
  			System.out.println(gender);
  			System.out.println(a);
  			//静态内部类中使用外部类中的成员内容,必须通过外部类对象,因为内部类是静态的,静态内容中不能直接使用非静态的内容
  			System.out.println(new Outer03().b);
  			System.out.println("静态内部类中的成员方法");
  		}
  	}
  	
  	//外部类中的成员方法
  	void outer(){
  		System.out.println(Inner.name);
  		System.out.println(new Inner().gender);
  		
  	}
  	
  }
  

  3)局部内部类

• 局部内部类只能在当前所定义的方法中通过对象使用

• 4)匿名内部类

  public class Outer05 {
  	public static void main(String[] args) {
  		//new Demo().swimming();
  		//匿名内部类 1) 只能使用以此
  		new Swim(){  //匿名内部类-->作为Swim接口实现类的类体
  			@Override
  			public void swimming() {
  				System.out.println("自由泳...");
  			}
  
  			@Override
  			public void sleep() {
  				System.out.println("边游泳边睡觉..");
  			}
  			
  		}.sleep();
  		
  		//2.引用指向匿名内部类对象
  		Swim s=new Swim(){  //接口多态
  			@Override
  			public void swimming() {
  				System.out.println("自由泳...");
  			}
  
  			@Override
  			public void sleep() {
  				System.out.println("边游泳边睡觉..");
  			}
  		};
  		s.swimming();
  		s.sleep();
  		
  		//3)匿名内部类作为方法的参数使用
  		test(new Swim(){
  
  			@Override
  			public void swimming() {
  				System.out.println("哈哈哈哈");
  			}
  
  			@Override
  			public void sleep() {
  				// TODO Auto-generated method stub
  			}
  			
  		});
  	}
  	
  	static void test(Swim s){
  		s.swimming();
  	}
  }
  
  //游泳接口
  interface Swim{
  	void swimming();
  	void sleep();
  }
  
  //测试有用的功能,定义一个实现类,但是这个实现类本身没有自己的作用
  /*class Demo implements Swim{
  
  	@Override
  	public void swimming() {
  		System.out.println("蛙泳...");
  	}
  }
  */