# Day11-Java基础

Posted zsr6135

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了# Day11-Java基础相关的知识，希望对你有一定的参考价值。

Day11-Java

文章目录

1、Eclipse开发工具

1.1 Eclipse历史

Eclipse中文翻译为日蚀，指的是吞没一切的光芒，那么这个及其具备挑衅一位的名字实际上是针对于SU年公司。在2000年之后一直处于互联网低潮，而SUN公司从这一低潮之后就再也没有起来过，而后SUN公司最为尴尬的是，他在硬件上没有过多的收益，而且软件的编程语言Java也不是SUN的赚钱工具，它只是变成了一个出卖版权的公司了。

对于Java的IDE（集成开发环境）本身也是经过了一些历史的调整。

​ 1995年的时候，Java诞生，但是SUN公司却高调宣布，我们自己不生成IDE，给其他第三方公司生产；

​ 在Java产生之后，Borland公司来时入手Java的IDE生产，所以后来的JBuilder就成为了Java开发的唯一选择（不选择JBuilder都使用记事本，IDEA,JCREATOR,EDIPLUS….），后俩一直到了JBuilderX之后才正常；

​ 2003年之后有了Eclipse，在2004年之后有了SUN自己的开发工具———NetBeans

而从整个国内的Java开发模式上也一直在发生着改变；

​ 豪华级架构：操作系统+数据库+中间件+开发工具+编程语言；

​ IBM体系：AIX+IBM DB2+WwbsphereApplicationServer+WSAD；

​ 超级杂牌军体系：UNIX+Oracle+Weblogic+JBuilder；

免费架构：Linux+mysql+Tomcat/JBoss+Eclipse；

而对于开发工具最早的霸主就是JBuilder，但是遗憾的是，2006年的时候Borland倒闭了，倒闭的原因是因为没有干声多为的开源风潮，因为有许多的学习者，它可能并不需要如此专业的工具，所以当时Borland公司的市场就出现了问题，于是倒闭就成为了必然，最后Borland技术部单独成立了一家技术公司，继续从事JBuilder的研究，但是今天的JBuilder已经基本上无法去问津了，完全被Eclipse取代了。

Eclipse是由IBM开发的，之后将其转送给了今天的Eclipse组织，进行开源项目的推广，而Eclipse的前身是IBM VisualAge，而后IBM根据Eclipse的1.0模型，产生后来的WSAD来发工具。Eclipse本身是免费的，但是其是靠插件收费（中国连插件都不需要收费），其本身有一下几个基本组成：JDT,JUNIT测试工具,CVS客户端，插件开发，用户可以直接登陆www.eclipse.org下载Eclipse的最新版本，JUNO（朱诺，小行星的名字）版，而且Eclipse现在可以直接解压缩后使用，不用单独的安装，是纯粹的绿色版。

当我们Java项目简历完成值周，可以在项目的目录小发现两个文件夹：

​ Src:是保存所有的*.java程序，都是按照包名称进行保存的；

​ Bin：保存所有生成的*.class文件，按照包名称进行保存的。

下面简历一个新的类：TestDemo.java

使用Eclipse本身最大的好处在于方便的进行随笔提示，并且在每一次*.java程序保存的时候，会由Eclipse自动的将其编译为*.class文件。

另外在Eclipse之中还可以存在一些代码生成工具，例如：现在有如下简单类

package com.sxau;

public class Person {
	private String name;
	private int age;
}

这个类肯定是作为简单Java类出现，那么现在很明显简单Java类的开发原则：

  1. 所有属性封装，已经封装；
  2. 生成setter，getter方法；
  3. 构造方法，必须要有无参构造
  4. 覆写Object中的一些方法
1.2 快捷键

除了以上的生成方式还可以通过快捷键生成

  1. ALT+/：代码自动补充提示；
  2. CTRL+1：进行错误代码矫正提示；
  3. CTRL+D：删除当前行代码；
  4. CTRL+SHIFT+O：自动导入包；
  5. CTRL+SHIFT+F：格式化代码显示；
  6. CTRL+/：注释/取消注释；
  7. CTRL+shift+l：快捷键列表
  8. CTRL+H：搜索

项目也可以进行删除操作，但是在删除项目的时候有两种方式：

​ 方式一：是从项目的工作区之中删除，以后可以恢复；

​ 方式二：彻底从硬盘上删除项目。

如果想导入项目则可以使用导入的方式。

​ 以上是利用导入的方式完成了项目的导入，而现在也可以通过导出的方式，将一个项目之中的所有*.class文件自动生成*.jar文件。

1.3 Debug调试

在Eclipse之中，为了方便永华的开发，还提供了DEBUG功能，可以利用此功能进行项目的调试操作，而如果要想进行调试，首先需要设置断点。断点指的是程序执行到此处的时候，自动停止，而后交给人工控制执行。

**范例：**设置断点

package com.util;

public class MyMath {
	private MyMath(){}
	public static int add(int x, int y){
		int temp = 0;
		temp = x + y;
		return temp;
	}
}

测试类

package com.test;

import com.util.MyMath;

public class TestMath {
	public static void main(String[] args) {
		int result = MyMath.add(2, 3);//将此处设置为断电
		System.out.println("加法结果" +  result);
	}
	
}

进入调试试图之后可以通过以下方式进行代码调试：

  1. 单步跳入（F5）：进入到代码之中观察代码的执行；
  2. 单步跳过（F6）：不关心代码之中的执行，只关心最终的结果；
  3. 单步返回（F7）：返回到单步跳过的状态
  4. 恢复执行（F8）：不再调试直接将程序运行完成。
1.4 JUNIT测试工具

软件测试行业：2003年——2006年之后，各个公司一直都在招聘软件测试人员，而且都是外包到IBM或微软的公司进行测试。但是，今天的软件测试来讲，这个行业已经很难了。

软件测试是一个黄金职位，对于软件测试是需要有一套完整测试理论和数据设计的，而如果学习过软件工程应该知道软件测试分为两类：

​ 1 黑盒测试：主要是测试功能，例如一些xx版，是不接触代码的，但是公司会提供工具；

​ 2 白盒测试：指的是性能测试，或者是算法调整。

而这几年随着行业的发展，实际上又给出了一种新的测试职位——Use Case(用测)测试工程师，对于这种职位而言，国内的平均待遇是程序员的3-5倍，如果按照正常的一个程序员的工资是8000来算，那么这种人的平均工资就是2-5万，但是人很难难找，一般而言此类人员在行业中需要8-10年的项目经验，并且精通业务。

JUNIT是一个比较常用的测试工具，准们可以进行Use Case测试的，在日后所开发的程序里都要写大量的JUNIT测试程序。

**范例：**定义要测试的程序

package com.util;

public class MyMath {
	private MyMath(){}
	public static int add(int x, int y){
		int temp = 0;
		temp = x + y;
		return temp;
	}
}

测试类

package com.test;

import static org.junit.Assert.*;

import org.junit.Test;

import com.util.MyMath;

import junit.framework.TestCase;

public class MyMathTest {

	@Test
	public void testAdd() {
		TestCase.assertEquals(MyMath.add(2, 3), 5);
	}

}

建立JUNIT测试的时候有两种形式：

​ 1.JUNIT Test Case：表示一个测试用例，主要完成一个业务的测试；

​ 2.JUNIT Test Case：表示一组测试用例，包含多个Test Case。

对于JUNIT的测试结果来说，一共分为两种：

​ 1.GREEM BAR：测试通过；

​ 2.RED BAR：测试失败。

2、Java基础新特性

Java的发展从1995年开始经历了许多的过程，但是有三个最具有代表性的JDK版本；

JDK1.0：标志着java的诞生；

JDK1.2：加入了javax.swing组件，这是主要新特性；

JDK1.5：标记为tiger，出现了许多一直沿用至今的特性；

JDK1.8：Lambda表达式、接口的定义加强

已经接触过了一些新特性，例如：自动装箱与拆箱、switch对String的判断支持。

2.1 可变参数

在讲解可变参数之前，首先思考一个问题：如果说现在要实现若干个整型变量的相加操作，问，此方法该如何设计？使用数组接收，因为参数个数不确定，按照之前所学，只能使用数组完成。

package com.demo;

/**
 * @author 张晟睿
 *
 */
public class TestDemo {
	public static void main(String[] args) {
		System.out.println(add(new int[]{1}));
		System.out.println(add(new int[]{1,2,3}));
		System.out.println(add(new int[]{1,2,3,4,5,6,7}));
	}
	
 /**
 * 实现任意个数的数据相加操作处理
 * @param data相加操作数据
 * @return	返回多个数据的相加结果
 */
public static int add(int [] data){
		int sum = 0;
		for (int i = 0; i < data.length; i++) {
			sum += data[i];
		}
		return sum;
	}
}

以上的确是实现了技术要求，但是现在有一个新的问题产生了：如果按照题目要求，应该是可以任意的传递多个数据，但是以上实际上传的是一个数据，只不过一个数据使用数组的形式封装。那么为了更好的解决这个问题，可以使用JDK1.5的可变参数的方式来解决此问题

Public [static]  [final] 返回值类型  方法名称（参数类型…变量）{	//虽然方式改变了
    [return [返回值];]
}

发现现在进行方法参数的定义的时候有了一些变化，而这个时候的参数可以说是数组形式。

package com.demo;

/**
 * @author 张晟睿
 *
 */
public class TestDemo {
	public static void main(String[] args) {
		System.out.println(add(1));
		System.out.println(add(1,2,3));
		System.out.println(add(1,2,3,4,5,6,7));
	}
	
 /**
 * 实现任意个数的数据相加操作处理
 * @param data相加操作数据
 * @return	返回多个数据的相加结果
 */
public static int add(int ... data){
		int sum = 0;
		for (int i = 0; i < data.length; i++) {
			sum += data[i];
		}
		return sum;
	}
}

有了可变参数在日后进行方法调用的过程之中，就可以比较直观的传递任意多个参数，但是异常的操作在开发之中不建议使用，最好别用。

2.2 foreach输出

首先需要解释的是：foreach并不是新的概念，最早是在NET中提出来的，多为foreach可以理解为增强型的for循环，下面来回顾一下最早的for循环：

package com.demo;

/**
 * @author 张晟睿
 *
 */
public class TestDemo {
	public static void main(String[] args) {
		System.out.println(add(1));
		System.out.println(add(1,2,3));
		System.out.println(add(1,2,3,4,5,6,7));
		
		
	}
	
 /**
 * 实现任意个数的数据相加操作处理
 * @param data相加操作数据
 * @return	返回多个数据的相加结果
 */
public static int add(int ... data){//接收原始数组
		int sum = 0;
		for (int i : data) {	//将数组中的每一个元素设置给x
			sum += i;//这种循环避免了脚标的问题
		}
		return sum;
	}
}

但是有了foreach之后，那么对于数组或者是集合的输出就有了新的支持，语法如下：

for(数据类型  变量 ：数组|集合){
    //操作代码
}

对于这种for循环避免了数组越界的问题，但依然只是要求会使用，能看懂就行，不过个人建议：最好别用。

2.3 静态导入

如果说想在想要导入一个不同包的类的方法，那么肯定使用import完成，即：如下是之前所采用的格式。

定义一个MyMath类

package com.util;

public class MyMath {
	private MyMath(){}
	public static int add(int x, int y){
		int temp = 0;
		temp = x + y;
		return temp;
	}
	public static int sub(int x,int y){
		return x-y;
	}
	public static int mul(int x,int y){
		return x*y;
	}
	public static int div(int x,int y){
		return x/y;
	}
}

在JDK1.5值周，如果一个雷之中的全部方法都是static型的，则可以使用如下的语法进行导入：

import static 包.类.*；

表示的是将这个指定类之中的全部方法导入进来，最后就好像这些方法全部都是在主类之中定义的一样。

package com.test;

import static com.util.MyMath.*;//静态导入

public class TestMath {
	public static void main(String[] args) {
		System.out.println(add(10,20));
		System.out.println(sub(30,10));
	}
}

这种比较难受的方法，也只是出现在讲课之中，本人是绝对不会使用的，你们也可以忘记它。

3、 JDK三大主要特性——泛型

泛型可以帮助我们解决参数转换的问题

3.1 泛型的引出

下面首先通过一个简单分析来研究一下泛型出现的主要目的是什么？例如现在要求定义一个表示坐标的操作类（Point）这个类可以表示三种类型的坐标：

​ 整数坐标：x=10、y=20；

​ 小数坐标：x=10.1、y=20.3；

​ 字符串数据：x=“东经10度”、y=“西经20度”。

类之中如果想要表示以上的数据，一定需要定义x和y两个属性，而且每一个属性可以接收三种数据类型，那么只能使用Object类来定义会比较合适，这样会发生如下的几种转换关系：

整数：int→自动装箱为Integer→向上转型为Object；

小数：double→自动装箱为Double→向上转型为Obejct;

字符串：字符串→向上转型为Obejct；

设置整形

package com.demo;
class Point {
	private Object x;
	private Object y;
	public Object getX() {
		return x;
	}
	public void setX(Object x) {
		this.x = x;
	}
	public Object getY() {
		return y;
	}
	public void setY(Object y) {
		this.y = y;
	}
}
public class PointDemo {
	public static void main(String[] args) {
		//第一步：设置数据
		Point p = new Point();
		p.setX(10);
		p.setY(20);
		//第二步：取出数据
		int x = (Integer)p.getX();
		int y = (Integer)p.getY();
		System.out.println("x = " + x + ",y = " + y);
	}
}

设置小数

package com.demo;
class Point {
	private Object x;
	private Object y;
	public Object getX() {
		return x;
	}
	public void setX(Object x) {
		this.x = x;
	}
	public Object getY() {
		return y;
	}
	public void setY(Object y) {
		this.y = y;
	}
}
public class PointDemo {
	public static void main(String[] args) {
		//第一步：设置数据
		Point p = new Point();
		p.setX(10.1);
		p.setY(20.2);
		//第二步：取出数据
		double x = (Double)p.getX();
		double y = (Double)p.getY();
		System.out.println("x = " + x + ",y = " + y);
	}
}

设置字符串

package com.demo;
class Point {
	private Object x;
	private Object y;
	public Object getX() {
		return x;
	}
	public void setX(Object x) {
		this.x = x;
	}
	public Object getY() {
		return y;
	}
	public void setY(Object y) {
		this.y = y;
	}
}
public class PointDemo {
	public static void main(String[] args) {
		//第一步：设置数据
		Point p = new Point();
		p.setX("东经10");
		p.setY("西经20");
		//第二步：取出数据
		String x = (String)p.getX();
		String y = (String)p.getY();
		System.out.println("x = " + x + ",y = " + y);
	}
}

看起来所有功能都实现了，并根据之前所学的内容，也只能做到这些了，但是本程序还有一系列问题。

本程序解决问题的关键就在Object类，所有的类型都可以想Obejct转换，但是成也是它败也是它。

public class PointDemo {
	public static void main(String[] args) {
		Point point = new Point();
		//设置参数
		point.setX(10);
		point.setY("北纬");
		//取出参数
		String x = (String) point.getX();
		String y = (String) point.getY();
		System.out.println("x的坐标是："+x+"y的坐标是："+y);
	}
}

这个时候程序并没有任何的语法错误，因为数字10 被包装成了Integer，可以使用Obejct接收，从技术上而言，本操作没有问题，但是从实际来讲，因为没有统一，多以在取得数据并且执行向下转型的过程中就会出现如下的错误提示信息：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at cn.mldn.demo.TestDemo.main(PointDemo.java:30)

所以，就可

以上是关于# Day11-Java基础的主要内容，如果未能解决你的问题，请参考以下文章

JAVA零基础入门系列Day11 Java中的类和对象

day06-jsp

[vscode]--HTML代码片段（基础版，reactvuejquery）

Day11:JAVA IO下

Java入门提高篇Day11 Java代理——JDK动态代理

[Go] 通过 17 个简短代码片段，切底弄懂 channel 基础