Java知识点复习

复习点1：打印圣诞树（多重for循环）

public class Chirstmas {

	public static void main(String[] args) {
		int h = 5;//定义层数
		for(int i=1;i<=h;i++){//控制层数
			for(int j=0;j<h-i;j++){//控制空格数 = 总层数 - 当前层数i
				System.out.print(" ");//打印空格
			}
			for(int k=0;k<i*2-1;k++){//控制*数 = 当前层数i*2-1
				System.out.print("*");//打印*
			}
			System.out.println();//打印一层后换行
		}
	}

}

复习点2：

面向过程（POP）-Process Oriented Programming

面向对象（OOP）-Object Oriented Programming

复习点3：

静态属性

和

静态方法

随着类的加载

保存在方法区

，而

实例

随着对象的建立

存在于堆内存

中

复习点4：Instanceof

Instanceof关键字用来判断一个对象是否是指定类所创建的实例

public class Test1 {

	public static void main(String[] args) {
		Person person = new Person();
		Person man = new Man();
		Person woman = new Woman();
		Test1.meeting(person,man,woman);
	}
	
	public static void meeting(Person...persons ){
		for(int i=0;i<persons.length;i++){
			persons[i].eat();
			persons[i].toilet();
			if(persons[i] instanceof Man){
				((Man)persons[i]).smoke();
			}else if(persons[i] instanceof Woman){
				((Woman)persons[i]).makeUp();
			}
		
		}
	}

}

复习点5：单例模式

public class Dog_1 {
	private static Dog_1 dog = null;//懒汉式
	private Dog_1(){
		
	}
	public static Dog_1 getDog(){
		if(dog==null){
			 dog = new Dog_1();
		}
		return dog = new Dog_1();
		
	}

}



public class Dog_2 {
	private static final Dog_2 dog = new Dog_2();//饿汉式
	private Dog_2(){
		
	}
	public static Dog_2 getDog(){
		return dog;
	}

}

复习点6：

接口中所有属性，默认修饰符是public static final

接口中所有方法，默认修饰符是public abstract

复习点7：匿名内部类

基于接口实现匿名内部类

public interface Product {
	public double getPrice();
	public String getName();

}



public class Demo {

	public static void main(String[] args) {
		Demo demo = new Demo();
		demo.printProduct(new Product(){
			
			@Override
			public double getPrice() {
				double price = 2.5;
				return price;
			}

			@Override
			public String getName() {
				String name = "water";
				return name;
			}
		});

	}
	
	public void printProduct(Product p){
		System.out.println(p.getName());
		System.out.println(p.getPrice());
	}

	

}

基于类实现匿名内部类

public abstract class Person {
	public abstract void eat();
	public abstract void sleep();

}



public class Test1 {

	public static void main(String[] args) {
		Test1 test = new Test1();
		test.printPerson(new Person(){

			@Override
			public void eat() {
				System.out.println("吃饭");
				
			}

			@Override
			public void sleep() {
				System.out.println("睡觉");
			}
			
		});
		

	}
	
	public void printPerson(Person p){
		p.eat();
		p.sleep();
	}

}

复习点8：日期和时间

public class Test1 {

	public static void main(String[] args) throws ParseException {
		Date date = new Date();
		Locale locale = Locale.getDefault();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss",locale);
		String time = dateFormat.format(date);
		System.out.println(time);
		
		String timeString = "2008-02-23  12:23:30";
		SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss",locale);
		Date parse = dateFormat2.parse(timeString);
		long time2 = parse.getTime();
		System.out.println(time2);

	}

}

复习点9：枚举

public class Test2 {
	
	enum  Season{
		SPRING,SUMMER,AUTUMN,WINTER;
	}

	public static void main(String[] args) {
			Season s = Season.SPRING;
			switch(s){
			case SPRING:
				System.out.println("春天");
				break;
			case SUMMER:
				System.out.println("夏天");
				break;
			case AUTUMN:
				System.out.println("秋天");
				break;
			case WINTER:
				System.out.println("冬天");
				break;
			
			}

	}

}

复习点9：二分法

public class Test04 {

	public static void main(String[] args) {
		int[] arr = new int[]{1,3,2,4,5,7,6};
		Arrays.sort(arr);//排序
		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println();
		
		int choose = Test04.choose(arr, 5);
		System.out.println(choose);
		

	}
	
	public  static  int choose(int[] arr ,int value ){
		int min = 0;
		int max = arr.length-1;
		int mid = (min + max)/2;
		while(arr[mid]!=value){
			if(max>min){
				if(value<arr[mid]){
					max = mid - 1;
					mid = (max + min)/2;
				}else if(value>arr[mid]){
					min = mid +1;
					mid = (max + min)/2;
				}
			}else{
				return -1;
			}
			
		}
		return mid;
	}

}

复习点10：递归算法

递归算法求斐波拉及第N项值

public class Test05 {
//0 1 1 2 3 5 8 13 21……
	public static void main(String[] args) {
		int fib = Test05.fib(8);
		System.out.println(fib);

	}
	
	public static int fib(int n){
		if(n>0){
			if(n==1){
				return 0;
			}
			if(n==2){
				return 1;
			}
			return fib(n-2)+fib(n-1);
		}else{
			return -1;
		}
	}

}

复习点11：集合应用场景

Collection	这是一个纯粹的接口，用于引用List,Set的实现对象。
List	如果需要保留存储顺序，并且允许保留重复元素，使用List 接口的实现类。如果查询较多，那么使用ArrayList。如果存取较多，那么使用LinkedList。如果需要线程安全，那么使用vector.
Set	如果不需要保留存储顺序，并且需要去掉重复元素，使用List 接口的实现类。如果我们需要将元素排序，那么使用TreeSet. 如果我们不需要排序，使用HashSet, HashSet比TreeSet效率高<br / > 如果我们不需要保留存储顺序，又要过滤重复元素，那么使用 LinkedHashSet.
Map	如果保留key/value形式数据，使用Map接口的实现类如果需要将元素排序，使用TreeSet。如果我们不需要排序，使用HashSet，HashSet比TreeSet效率高。

复习点12：HashMap两种遍历方式

public class Test02 {

	public static void main(String[] args) {
		HashMap<String, String> hashMap = new HashMap<>();
		hashMap.put("云南", "昆明");
		hashMap.put("四川", "成都");
		hashMap.put("贵州", "贵阳");
		hashMap.put("广西", "南宁");
		//使用KeySet
	    //将key转成Set集合，通过迭代器取出Set集合中的每一个key,再通过key获取相应的value
		Set<String> keySet = hashMap.keySet();
		Iterator<String> iterator = keySet.iterator();
		while(iterator.hasNext()){
			String key = iterator.next();
			String value = hashMap.get(key);
			System.out.println("key="+key+"  value"+value);
		}
		//这种方式一般不使用。
		//将key.value转成Set集合(entrySet()),通过迭代器取出Set集合中的每一个entrySet.
		
		Set<Entry<String,String>> entrySet = hashMap.entrySet();
		Iterator<Entry<String, String>> iterator2 = entrySet.iterator();
		while(iterator2.hasNext()){
			Entry<String, String> entry = iterator2.next();
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println("key="+key+"  value"+value);
		}
		
	

	}

}

原文链接：https://blog.csdn.net/weixin_48291026/article/details/119612168