Java Review

从今天起复习Java，相信到最后一定会考过哒。

1.接口中的方法默认是public abstract方法，因此我们在编写接口的实现类的时候，方法的实现前面要显式的加上public访问控制符。

2.异常也是一个对象，java里面什么都是对象

3.Java语言中，变量名可以用汉字表示

4.StringBuffer类是线程安全的，StringBuilder类是线程不安全的

5.子类不继承父类的构造方法，他的原则就是子类继承父类的成员属性，包括实例成员变量和类成员变量。子类也可以继承除构造方法之外的所有成员方法，包括实例成员方法和类成员方法。

6.程序运行中可以不改变数组的大小

7.以下关于构造函数。

1. 构造函数的返回类型不能指定
2. 构造函数是类的一种特殊函数，它的方法名必须与类名相同。
3. 构造函数的主要作用是完成对类的对象的初始化工作。
4. 一般在创建新对象时，系统会自动调用构造函数。

8. 如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象（FileInputStream）。 (2分)

9.

Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。

Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串，字符流处理的单元为2个字节的Unicode字符.

字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以

字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串；

文本用字符流，其余都用字节流。

面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
总结：以InputStream（输入）/OutputStream（输出）为后缀的是字节流；
以Reader（输入）/Writer（输出）为后缀的是字符流。
扩展：Java流类图结构，一目了然，解决大部分选择题：

10.Java里面类只允许单一继承,但允许实现多个接口。接口可以实现多继承

在Java中一个类也可以同时继承一个类和实现一个接口

例如：

package test;
class Bird {
    int legnum = 2;
 
    void egg() {
    };
    
}
interface Flyanimal{     
	   void fly();  
	}
class Pigeon  extends Bird implements  Flyanimal {  
	   public void fly(){  
	       System.out.println("pigeon  can fly");  
	   }  
	   public void egg(){  
	       System.out.println("pigeon  can lay  eggs ");  
	   }
}

public class Main{

	public static void main(String[] args) {
		Pigeon ff = new Pigeon();
		ff.fly();
		ff.egg();

	}

}
/*输出
pigeon  can fly
pigeon  can lay  eggs 
*/

 

11.java异常

Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

 异常分为非检查异常：Error 和 RuntimeException 以及他们的子类。

检查异常：除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过

语法

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

例如

package test;
import java.io.*;

public class TT {

	public static void main(String[] args) {
		int a[] = new int [2];
		a[1] = 0;
		try
		{
			System.out.println(a[3]);
		}
		catch(Exception e)
		{
			System.out.println(e);
			System.out.println(a[1]);
		}
		
	}

}

 

 

 

 

记事本敲代码，javac命令编译，java命令运行

Java虚拟机JVM：解释执行.class文件（字节码），把字节码解释成具体平台上的机器指令执行

Java运行环境JRE：运行Java程序所必须的环境的集合，包括Java 虚拟机 (JVM)、Java核心类和支持文件。 不包含开发工具 --编译器、调试器和其它工具

Java平台JDK由Java应用编程接口（API）和Java虚拟机（JVM）构成，这个平台构成了Java在不同计算机系统中编译和运行的环境

final定义常量——用符号表示常量

关键字：为编译器保留的、具有特定含义的标识符，不能把它用做变量、类或方法的名称，所有的关键字都是小写

boolean类型，

任何程序流程均可以用顺序结构、选择结构、循环结构这三种基本控制结构实现。

面向对象的特点：封装性，继承性，多态性

类和对象的关系：类是对象的定义，对象是类的实例。

引用：Java中除了基本类型以外的变量类型都是引用类型，存放在栈内存区。

§一个方法执行时都会建立自己的内存栈，在方法内定义的变量会逐个放入这个栈内存中。

Ø方法执行结束时方法的内存栈也将自然销毁。

§在程序中创建一个对象时，该对象被保存在运行时数据区，以便反复利用（创建对象成本比较大），该“运行时数据区”是堆内存。对象不会随方法的结束而销毁

 

接口

 

 

接口和抽象类用法上的不同

 

不可变的字符序列 字符串

枚举类型不能通过new创建实例对象  

 容器

分两类

Collection ：List，Set，Queue，

Map

 

HashSet 

 

TreeSet 

实现了排序功能，默认按字典序

定制按compareTo排序，TreeSet(Comparator<? super E> comparator)

 

 HashMap

Hashtable

 

 

 

ListIterator 

 

list中指定元素删除

public static List<String> convertStringToList(String str)
	{
		List<String > p = new ArrayList<String>() ;
		String s[] = str.split(" ");
		for(int i = 0; i < s.length; i++)
		{
			p.add(s[i]);
		}
		Iterator it = p.iterator();
		while(it.hasNext())
		{
			if(it.next().equals("")) it.remove();
		}
		return p;
	}
    /*remove函数代码*/
	public static void remove(List <String> list,String str)
	{
		Iterator it = list.iterator();
		while(it.hasNext())
		{
			if(it.next().equals(str)) it.remove();
		}
	}

 object

int n = sc.nextInt();
	    Object ob[] = new Object[n];
	    for(int i = 0; i < n; i++)
	    {
	    	String s = sc.next();
	    	if(s.equals("c"))
	    	{
	    		Computer t = new Computer();
	    		ob[i] = t;
	    	}
	    	else if(s.equals("d"))
	    	{
	    		String ss = sc.next();
	    		ob[i]  = new Double(ss);
	    		
	    	}
	    	else if(s.equals("i"))
	    	{
	    		String ss = sc.next();
	    		ob[i]  = new Integer(ss);
	    		//ob[i] = t;
	    	}
	    	else if(s.equals("s"))
	    	{
	    		ob[i]  = sc.next();
	    		//ob[i] = t;
	    	}
	    	else ob[i] = null;
	    }
	    for(int i = n-1; i >= 0; i--)
	    {
	    	if(ob[i] instanceof String)
	    	System.out.println((String)ob[i]);
	    	else if(ob[i] instanceof Double)
		    System.out.println((Double)ob[i]);
	    	else if(ob[i] instanceof Integer)
		    	System.out.println((Integer)ob[i]);
	    	else if(ob[i] instanceof Computer) {
	    		//Computer c = ;
		    	System.out.println(((Computer)ob[i]).toString());
	    	}
	    }

 

jmu-Java&Python-统计文字中的单词数量并按出现次数排序

package test;

import java.util.*;
import java.util.Map.Entry;
public class Main {

	public static void main(String[] args) {
		Map<String, Integer> map = new TreeMap<>();
		Scanner sc = new Scanner(System.in);
		while(true)
		{
			String s = sc.next();
			if(s.equals("!!!!!"))
			{
				break;
			}
			else {
				if(s.contains("!")||s.contains(",")||s.contains(".")||s.contains("*")||s.contains("?")
						||s.contains(":")	)
					s = s.substring(0, s.length()-1);
				s = s.toLowerCase();
				if(map.containsKey(s)) map.put(s,map.get(s)+1);
				else map.put(s,1);
			}
		}
		List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
		Collections.sort(list,new Comparator<Map.Entry<String, Integer>>()
				{
					public int compare(Entry<String,Integer> o1, Entry<String, Integer>o2)
					{
						return o2.getValue().compareTo(o1.getValue());
					}
					
				}
			);
		System.out.println(map.size());
		int cnt = 1;
		for(Map.Entry<String, Integer> en:list)
		{
			if(cnt >10)break;
			System.out.println(en.toString());
			cnt++;
		}
	}

}

悄悄关注

package test;

import java.util.*;
import java.util.Map.Entry;
public class Main {
	public static void main(String[]args)
	{
		Scanner sc = new Scanner(System.in);
		List<String> list= new ArrayList<>();
		int n = sc.nextInt();
		String s1 = sc.nextLine();
		String[]s2 = s1.split(" ");
		int l = s2.length;
		for(int i = 0; i < l; i++)
		{
			list.add(s2[i]);
		}
		int m = sc.nextInt();
		sc.nextLine();
		double aver = 0, sum = 0;
		Map<String,Integer> peo = new TreeMap<String,Integer>();
		for(int i = 0; i < m; i++)
		{
			String a = sc.next();
			int b = sc.nextInt();
			peo.put(a,b);
			sum+=b;
		}
		List<Map.Entry<String, Integer> >ll = new ArrayList<>(peo.entrySet());
		Collections.sort(ll, 
				new Comparator<Map.Entry<String, Integer>>()
		{
			public int compare(Entry<String,Integer>o1, Entry<String,Integer>o2)
			{
				return o2.getValue().compareTo(o1.getValue());
			}
		}
				);
		aver = sum*1.0/(1.0*m);
		//System.out.println(aver);
		int flag = 0;
		Set<String>set = new TreeSet<>();
		for(Map.Entry<String, Integer>en:ll)
		{
			double temp = en.getValue();
			String ss = en.getKey();
			//System.out.println(temp+ " "+ss);
			if(temp>aver) 
			{
				if(!list.contains(ss))
				{
					flag++;
					set.add(ss);
				}
			}
			else break;
		}
		Iterator it = set.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
		if(flag==0)System.out.println("Bing Mei You");
		
	}
}

 Comparator

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
class PersonSortable2{
	String name;
	int age;
	PersonSortable2(String s, int n)
	{
		name = s;
		age = n;
	}
	public String toString()
	{
		return name+"-"+age;
	}
}
class NameComparator implements Comparator<PersonSortable2>
{

	@Override
	public int compare(PersonSortable2 a1, PersonSortable2 a2) {
		// TODO Auto-generated method stub
		return a1.name.compareTo(a2.name);
	}
	
}
class AgeComparator implements Comparator<PersonSortable2>
{

	@Override
	public int compare(PersonSortable2 arg0, PersonSortable2 arg1) {
		// TODO Auto-generated method stub
		if(arg0.age > arg1.age) return 1;
		else if(arg0.age == arg1.age) return 0;
		else return -1;
	}
	
}

public class Main {
	
	
public static void main(String []args)
{
	Scanner sc = new Scanner(System.in);
	int n = Integer.parseInt(sc.nextLine());
	PersonSortable2 peo[] = new PersonSortable2[n];
	for(int i = 0; i < n; i++){
		String s = sc.nextLine();
		String ss[] = s.split(" ");
		int t = Integer.parseInt(ss[ss.length-1]);
		peo[i] = new PersonSortable2(ss[0],t);
		
	}
	Arrays.sort(peo,new NameComparator());
	System.out.println("NameComparator:sort");
	for(int i = 0; i < n; i++)
	{
		System.out.println(peo[i].toString());
	}
	Arrays.sort(peo,new AgeComparator());
	System.out.println("AgeComparator:sort");
	for(int i = 0; i < n; i++)
	{
		System.out.println(peo[i].toString());
	}
	System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
	System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
}
}