Javaweb崔希凡---day7---Java基础加强

最新推荐文章于 2019-02-24 12:11:16 发布

Carmen_W

最新推荐文章于 2019-02-24 12:11:16 发布

阅读量382

点赞数

分类专栏： javaweb 文章标签： javaweb java基础

本文链接：https://blog.csdn.net/xw_Summer/article/details/87740862

版权

javaweb 专栏收录该内容

12 篇文章 2 订阅

订阅专栏

在这里插入图片描述
1、myeclipse的安装和使用

2、debug的调试模式（断点调试模式）

package cn.itcast.test;

import java.util.Arrays;

public class TestDemo3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr1 = {10,2,5,30,20,11,25};
	//debug查看源代码
		Arrays.sort(arr1);
		System.out.println(Arrays.toString(arr1));
	}

}

3、myeclipse的快捷键的使用
在这里插入图片描述
常见快捷键：

Alt + / 代码引导 

Ctrl + T 在方法上按此键可进入实现类 

Ctrl + 鼠标左键 在方法上按此键可进入接口 

Ctrl + Alt + H 在方法上按此键可进入调用此方法的上一级方法 

Ctrl + O 显示当前类中所有方法的列表 

Ctrl + Shift + O 导入缺少的包 

Ctrl + Shift + R 根据文件名搜索文件 

Ctrl + Shift + I 进入断点在参数上按此键显示具体内容 

Ctrl + H 根据内容搜索文件 

Ctrl + F 根据内容搜索当前文件 

Ctrl + K 根据内容向下搜索当前文件 

Ctrl + Shift + K 根据内容向上搜索当前文件 

Ctrl + Alt + 上或下 复制选中文本 

Alt + 上或下 移动选中文本 

Ctrl + Alt + / 拼写自动补全 

Ctrl + Shift + F 格式化文本 

F6 断点单步运行 

F8 按一次执行一个断点

Ctrl   +   o 在编辑器中打开类结构,适用在编辑框最大化的时候,跳转函数用... 

Ctrl   +   t  也是在编辑器中使用,打开选择的元素的继承树,可以迅速定位父类的方法在子类中的覆盖位置 

Alt   +   <-(左右箭头):   编辑器的回退,就是著名的BACK! 

Ctrl   +   F6       :   切换编辑编辑器,我改成了Table+ctrl 

ctrl+/:注释 

ctrl+\:取消注释

package cn.itcast.test;

import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * java的常用的快捷键
 * 
 * @author asus
 * 
 */
public class TestDemo4 {

	public static void main(String[] args) throws Exception {
		// 代码提示 alt /
		new FileOutputStream("");

		// 代码修复 ctrl 1
		// 快速导包 ctrl shift o
		List list = new ArrayList();

		// 单行注释 ctrl /
		// 取消单行注释 ctrl /
		// int sum = 0;

		// 多行注释 ctrl shift /
		// 取消多行注释 ctrl shift \
		/*
		 * int a = 1; int b = 2;
		 */

		// 删除行 ctrl d
		int aa = 10;

		// 代码的格式化 ctrl shift F 有时候不好使，点击Source-- Format
		//有缩进的效果
		

	}
}

4、junit的使用
在这里插入图片描述

package cn.itcast.test02;

public class TestJunit {

	public void testAdd(int a,int b) {
		System.out.println(a+b);
	}
	
	public void test11() {
		System.out.println("test11.....");
	}
}

package cn.itcast.test02;

import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

public class TestDemo {

	@Before
	public void testBefore() {
		System.out.println("before....");
	}

	@Test
	public void testAdd1() {
		TestJunit test01 = new TestJunit();
		test01.testAdd(2, 3);
		
		//int m = 10/0;
	}
	
	@Test
	public void test12() {
		System.out.println("test12");
	}
	
	@Ignore
	public void tests11() {
		TestJunit test01 = new TestJunit();
		test01.test11();
	}
	
	@After
	public void testAfter() {
		System.out.println("after.....");
	}
}

package cn.itcast.test02;

import junit.framework.Assert;

import org.junit.Test;

public class TestDemo2 {

	@Test
	public void test02() {
		int a = 3;
		int b = 5;
		int sum = a+b;
		//使用断言
		//Assert.assertEquals("测试期望的值", "方法运行的实际的值")
		Assert.assertEquals(80, sum);
	}
}

在这里插入图片描述
5、泛型的简介

package cn.itcast.test03;

import java.util.ArrayList;
import java.util.List;

public class TestDemo1 {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		
		//如果不用泛型，比如把aaa值取出来，类型转换，转换int类型，会类型转换的错误
		
		
	}
}

在这里插入图片描述

package cn.itcast.test03;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

/**
 * 泛型在集合上的使用
 * @author asus
 *
 */
public class TestDemo02 {

	//在map上使用泛型
	@Test
	public void testMap() {
		Map<String,String> map = new HashMap<String,String>();
		map.put("aaa", "111");
		map.put("bbb", "222");
		map.put("ccc", "333");
		//遍历map 有几种遍历方式 两种
		// 1、获取所有的key，通过key得到value 使用get方法
		// 2、获取key和value的关系
		//使用第一种方式遍历
		//获取所有的key
		Set<String> sets = map.keySet();
		//遍历所有key返回的set
		for (String key : sets) {
			//通过key得到value
			String value = map.get(key);
			System.out.println(key+" : "+value);
		}
		
		System.out.println("==============");
		//得到key和value的关系
		Set<Entry<String, String>> sets1 = map.entrySet();
		//遍历sets1
		for (Entry<String, String> entry : sets1) {
			//entry是key和value关系
			String keyv = entry.getKey();
			String valuev = entry.getValue();
			System.out.println(keyv+" : "+valuev);
		}
	}
	
	//泛型使用set集合上
	@Test
	public void testSet() {
		Set<String> set = new HashSet<String>();
		set.add("www");
		set.add("qqq");
		set.add("zzz");
		//set.add("qqq");
		//遍历set 有几种方式  两种
		//迭代器  增强for
		//使用增强for遍历
		for (String s2 : set) {
			System.out.println(s2);
		}
		System.out.println("=================");
		//使用迭代器遍历
		Iterator<String> it1 = set.iterator();
		while(it1.hasNext()) {
			System.out.println(it1.next());
		}
	}
	
	//泛型在list上的使用
	@Test
	public void testList() {
		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		//遍历list集合 有几种方式  三种
		//普通for循环  迭代器  增强for
		//普通for循环
		for(int i=0;i<list.size();i++) {
			String s = list.get(i);
			System.out.println(s);
		}
		System.out.println("=================");
		//使用增强for
		for (String s1 : list) {
			System.out.println(s1);
		}
		System.out.println("=================");
		//使用迭代器遍历
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

6、泛型使用在方法上
在这里插入图片描述

package cn.itcast.test03;

import java.util.Arrays;

/**
 * 定义一个数组，实现指定位置上数组元素的交换
 * @author asus
 *
 */
public class TestDemo03 {

	public static void main(String[] args) {
		//创建一个数组 实现11和13位置交换
		Integer[] arr1 = {10,11,12,13,14};
		System.out.println(Arrays.toString(arr1));
		swap1(arr1,1,3);
		System.out.println(Arrays.toString(arr1));
		
		System.out.println("=========================");
		//创建一个string类型的数组 实现 bb和dd位置交换
		String[] arr2 = {"aa","bb","cc","dd","ff"};
		System.out.println(Arrays.toString(arr2));
		swap1(arr2,1,3);
		System.out.println(Arrays.toString(arr2));

	}
	
	/*
	 * 使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型
	 * 写在返回值之前 void之前 <T>
	 * =======表示定义了一个类型 这个类型是 T
	 * 在下面就可以使用这个类型了  T
	 * */
	
	public static <T> void swap1(T[] arr ,int a,int b) {
		T temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	
	/*private static void swap1(String[] arr2, int i, int j) {
		String temp1 = arr2[i];
		arr2[i] = arr2[j];
		arr2[j] = temp1;
	}

	private static void swap1(int[] arr1, int i, int j) {
		//定义一个中间变量
		int temp = arr1[i];
		arr1[i] = arr1[j];
		arr1[j] = temp;
	}*/

}

7、泛型在类上的使用（了解）
在这里插入图片描述

package cn.itcast.test03;

public class TestDemo04<T> {
	
	//在类里面可以直接使用T的类型
	T aa;
	public void test11(T bb) {}
	
	//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
	public static <A> void test12(A cc) {}
}

8、枚举的简介
在这里插入图片描述

package cn.itcast.test04;

public class TestEnum1 {
	//传统的方式
	private int color;
	
	//第二种方式
	private Color2 color1;
	
	//第三种方式 jdk5.0新特性 使用枚举
	private Color3 color3;
	
	public void test() {
		this.color = 1000;//Color1.RED;
		this.color1 = Color2.RED;
		this.color3 = Color3.GREEN;
	}
}

//使用枚举实现
enum Color3 {
	RED,GREEN,YELLOW;
}

class Color2 {
	//构造方法私有化
	private Color2(String name){}
	public static final Color2 RED = new Color2("");
	public static final Color2 GREEN = new Color2("");
	public static final Color2 YELLOW = new Color2("");
}

class Color1 {
	public static final int RED = 1;
	public static final int GREEN = 2;
	public static final int YELLOW = 3;
}

package cn.itcast.test04;

public class TestEnum2 {

}

enum Color11 {
	RED("red"){

		@Override
		public void print1() {
			System.out.println("red");
			
		}
		
	},GREEN("green"){

		@Override
		public void print1() {
			System.out.println("green");
			
		}
		
	},YELLOW("yellow") {

		@Override
		public void print1() {
			System.out.println("yellow");
			
		}
	};
	private Color11(String name) {}
	//抽象方法
	//当在枚举里面写了抽象方法之后，需要在每个实例上面都实现抽象方法
	public abstract void print1();
}

9、枚举的api的操作

在这里插入图片描述

package cn.itcast.test04;

import org.junit.Test;

public class TestEnum3 {
	
	//知道枚举的下标，得到枚举的对象和名称
	@Test
	public void test3() {
		int idx2 = 2;
		//得到枚举的对象
		Color100[] cs = Color100.values();
		//根据下标得到对象
		Color100 c12 = cs[idx2];
		//得到枚举的名称
		String name = c12.name();
		System.out.println(name);
	}
	
	//知道枚举的名称，得到枚举的对象和下标
	@Test
	public void test2() {
		String name1 = "GREEN";
		//得到对象
		Color100 c1 = Color100.valueOf(name1);
		//枚举下标
		int idx1 = c1.ordinal();
		System.out.println(idx1);
	}

	//知道枚举的对象，得到枚举名称和下标
	@Test
	public void test1() {
		//得到枚举对象
		Color100 c100 = Color100.RED;
		//枚举名称
		String name = c100.name();
		//枚举的下标
		int idx = c100.ordinal();
		System.out.println(name+" "+idx);
	}
}

enum Color100 {
	RED,GREEN,YELLOW;
}

10、静态导入(了解)
在这里插入图片描述

package cn.itcast.test05;
/**
 * 演示静态导入
 * @author asus
 *
 */
import static java.lang.System.out;
import static java.util.Arrays.sort;
import static java.util.Arrays.toString;
public class TestDemo1 {

	public static void main(String[] args) {
		out.println("hello");
		
		int[] arr1 = {10,1,3,20,15};
		sort(arr1);
		//System.out.println(toString(arr1));//会出错
	}
}

11、自动拆装箱
在这里插入图片描述

package cn.itcast.test06;

public class TestDemo1 {
	
	public static void main(String[] args) {
		//自动装箱
		Integer i = 10;	
		//自动拆箱
		int m = i;
	}
	//在jdk1.4里面实现拆装箱
	public void test1() {
		//装箱
		Integer m = new Integer(10);		
		//拆箱	
		int a = m.intValue();
	}
}

package cn.itcast.test06;

public class TestDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		doSomething(10);

	}
	
	public static void doSomething(double m) {
		System.out.println("double......");
	}
	
	public static void doSomething(Integer a){
		System.out.println("integer.....");
	}

}

12、增强for循环（*）
在这里插入图片描述

package cn.itcast.test07;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestDemo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//创建list
		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		//使用增强for循环
		for(String s : list) {
			System.out.println(s);
		}
		System.out.println("==============================");
		//使用迭代器实现
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

}

13、内容补充
在这里插入图片描述

package cn.itcast.test07;

import java.util.Arrays;

/**
 * 实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素
 * @author asus
 *
 */
public class TestDemo2 {

	public static void main(String[] args) {
		Integer[] arr1 = {10,12,13,14,20};
		System.out.println(Arrays.toString(arr1));
		//写方法实现颠倒
		reverses(arr1);
		System.out.println(Arrays.toString(arr1));
		
		System.out.println("====================");
		
		String[] arr2 = {"aa","bb","cc","dd","ff"};
		System.out.println(Arrays.toString(arr2));
		reverses(arr2);
		System.out.println(Arrays.toString(arr2));
	}
	
	public static <T> void reverses(T[] arr1) {
		/*
		 * 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。
		 * 交换 长度/2
		 * */
		//遍历数组
		for(int i=0;i<arr1.length/2;i++) {
			/*int temp = arr1[0];
			arr1[0] = arr1[arr1.length-1];*/
			T temp = arr1[i];
			arr1[i] = arr1[arr1.length-i-1];
			arr1[arr1.length-i-1] = temp;
		}
		
	}

	/*public static void reverses(Integer[] arr1) {
		
		 * 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。
		 * 交换 长度/2
		 * 
		//遍历数组
		for(int i=0;i<arr1.length/2;i++) {
			int temp = arr1[0];
			arr1[0] = arr1[arr1.length-1];
			int temp = arr1[i];
			arr1[i] = arr1[arr1.length-i-1];
			arr1[arr1.length-i-1] = temp;
		}
		
	}*/

}

14、可变参数
在这里插入图片描述

package cn.itcast.test08;
/**
 * 演示可变参数
 * @author asus
 *
 */
public class TestDemo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int..num;
		add1(10,20);
		add1(10,20,30);
		add1(10,20,30,40);
	}
	
	public static void add1(int a,int...nums) {
		//nums理解为一个数组，这个数组存储传递过来的参数
		//System.out.println(nums.length);
		int sum = 0;
		//遍历数组
		for(int i=0;i<nums.length;i++) {
			sum += nums[i];
		}
		System.out.println(sum);
	}
	
	/*//实现两个数的相加
	public void add1(int a,int b) {
		int sum = a+b;
		System.out.println(sum);
	}
	
	//实现三个数的相加
	public void add1(int a,int b ,int c) {
		int sum = a+b+c;
		System.out.println(sum);
	}
	
	//实现四个数的相加
	public void add1(int a,int b ,int c,int d) {
		int sum = a+b+c+d;
		System.out.println(sum);
	}*/
}

15、反射的原理（理解）
在这里插入图片描述

16、使用反射操作类里面的无参数的构造方法（会写）

17、使用反射操作有参数的构造方法（会写）

18、使用反射操作属性（会写）

19、使用泛型操作普通方法（会写）

package cn.itcast.test09;

public class Person {
	//属性
	private String name;
	private String id;
	//没有参数的构造方法
	public Person() {}
	//有参数的构造
	public Person(String name, String id) {
		this.name = name;
		this.id = id;
	}  
	//普通方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
}

package cn.itcast.test09;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.Test;

public class TestDemo1 {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// 获取Class类
		Class clazz1 = Person.class;
		Class clazz2 = new Person().getClass();
		Class clazz3 = Class.forName("cn.itcast.test09.Person");

	}
	
	//操作普通方法 ，比如操作 setName
	@Test
	public void test4() throws Exception {
		//得到Class类
		Class c4 = Class.forName("cn.itcast.test09.Person");
		//得到Person实例
		Person p4 = (Person) c4.newInstance();
		//得到普通方法
		//c4.getDeclaredMethods();//得到所有的普通方法
		Method m1 = c4.getDeclaredMethod("setName", String.class);
		//操作的私有的方法 ，需要设置值是true
		//m1.setAccessible(true);
		//让setName方法执行 ，执行设置值
		m1.invoke(p4, "niuqi");
		System.out.println(p4.getName());
	}
	
	//操作name属性
	@Test
	public void test3() {
		try {
			//得到Class类
			Class c2 = Class.forName("cn.itcast.test09.Person");
			//得到name属性
			//c2.getDeclaredFields();//表示得到所有的属性
			//得到Person类的实例
			Person p11 = (Person) c2.newInstance();
			Field f1 = c2.getDeclaredField("name");
			//设置可以操作私有属性
			f1.setAccessible(true);
			//设置name值
			f1.set(p11, "wangwu"); //相当于 在 p.name = "wangwu";
			System.out.println(f1.get(p11)); //相当于 p.name
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	//操作有参数的构造方法
	@Test
	public void test2() throws Exception {
		//得到Class
		Class c1 = Class.forName("cn.itcast.test09.Person");
		//使用有参数的构造方法
		//c1.getConstructors();//获取所有的构造方法
		//传递是有参数的构造方法里面参数类型，类型使用class形式传递
		Constructor cs = c1.getConstructor(String.class,String.class);
		//通过有参数的构造方法设置值
		//通过有参数的构造方法创建Person实例
		Person p1 = (Person) cs.newInstance("lisi","100");
		System.out.println(p1.getId()+" "+p1.getName());
	}
	
	//操作无参数的构造方法
	@Test
	public void test1() throws Exception {
		//得到Class
		Class c3 = Class.forName("cn.itcast.test09.Person");
		//得到Person类的实例
		Person p = (Person) c3.newInstance();
		//设置值
		p.setName("zhangsan");
		System.out.println(p.getName());
	}
	

}

Carmen_W

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Javaweb崔希凡---day7---Java基础加强

1、myeclipse的安装和使用2、debug的调试模式（断点调试模式）package cn.itcast.test;import java.util.Arrays;public class TestDemo3 { /** * @param args */ public static void main(String[] args) { int[] arr1...
复制链接

扫一扫