王之泰201771010131《面向对象程序设计（java）》第九周学习总结
第一部分：理论知识学习部分
第7章异常、日志、断言和调试
概念：异常、异常类型、异常声明、异常抛出、 异常捕获
1.异常处理技术
2.断言的概念及使用
3.基本的调试技巧
1）异常的概念
a.Java的异常处理机制可以控制程序从错误产生的 位置转移到能够进行错误处理的位置。
b.程序中出现的常见的错误和问题有:用户输入错误 ；设备错误 ；物理限制 ；代码错误。
2）异常分类：
a.非致命异常:通过某种修正后程序还能继续执行。 这类错误叫作异常。如：文件不存在、无效的数组 下标、空引用、网络断开、打印机脱机、磁盘满等。 Java中提供了一种独特的处理异常的机制，通过异 常来处理程序设计中出现的错误。
b.致命异常：程序遇到了非常严重的不正常状态，不 能简单恢复执行，是致命性错误。如：内存耗尽、 系统内部错误等。这种错误程序本身无法解决。
3） Java中所有的异常类都直接或间接地继承于 Throwable类。除内置异常类外，程序员可自定义异 常类。
Java中的异常类可分为两大类：
a.Error Error类层次结构描述了Java运行时系统的内部错误 和资源耗尽错误。应用程序不应该捕获这类异常，也 不会抛出这种异常。
b.Exception Exception类：重点掌握的异常类。Exception层次结 构又分解为两个分支：一个分支派生于 RuntimeException；另一个分支包含其他异常
第二部分：实验部分 ——异常、断言与日志
1、实验目的与要求
(1) 掌握java异常处理技术；
(2) 了解断言的用法；
(3) 了解日志的用途；
(4) 掌握程序基础调试技巧；
2、实验内容和步骤
实验1：用命令行与IDE两种环境下编辑调试运行源程序ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别。
//异常示例1
public class ExceptionDemo1 {
public static void main(String args[]) {
int a = 0;
System.out.println(5 / a);
}
}
//异常示例2
import java.io.*; public class ExceptionDemo2 {
public static void main(String args[])
{
FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
int b;
while((b=fis.read())!=-1)
{
System.out.print(b);
}
fis.close();
}
}
检查异常后：
package 异常; //异常示例1
public class ExceptionDemo1 {
public static void main(String args[]) {
int a=0;
if(a==0) {
System.out.println("除数为零！");
}
else {
System.out.println(5 / a); }
}
}
package 异常; //异常示例2
import java.io.*; public class ExceptionDemo2 {
public static void main(String args[]) throws Exception
{
FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
int b;
while((b=fis.read())!=-1)
{
System.out.print(b);
}
fis.close();
}
}
在项目文件夹中添加相应的TXT文件
实验2： 导入以下示例程序，测试程序并进行代码注释。
测试程序1：
1.在elipse IDE中编辑、编译、调试运行教材281页7-1，结合程序运行结果理解程序；
2.在程序中相关代码处添加新知识的注释；
3.掌握Throwable类的堆栈跟踪方法；
7-1代码如下：
package stackTrace; import java.util.*; /**
* A program that displays a trace feature of a recursive method call.
* @version 1.01 2004-05-10
* @author Cay Horstmann
*/
public class StackTraceTest
{
/**
* Computes the factorial of a number
* @param n a non-negative integer
* @return n! = 1 * 2 * . . . * n
*/
public static int factorial(int n)
{
System.out.println("factorial(" + n + "):");
Throwable t = new Throwable();//调用Throwable类的getStackTrace方法，得到StackTraceElement对象的一个数组
StackTraceElement[] frames = t.getStackTrace();
for (StackTraceElement f : frames)
System.out.println(f);
int r;
if (n <= 1) r = 1;
else r = n * factorial(n - 1);
System.out.println("return " + r);
return r;
} public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
System.out.print("Enter n: ");
int n = in.nextInt();
factorial(n);
}
}
程序运行结果如下：
测试程序2：
1.Java语言的异常处理有积极处理方法和消极处理两种方式；
2.下列两个简答程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionalTest.java，将程序中的text文件更换为身份证号.txt，要求将文件内容读入内容，并在控制台显示；
3.掌握两种异常处理技术的特点。
//积极处理方式
import java.io.*; class ExceptionTest {
public static void main (string args[])
{
try{
FileInputStream fis=new FileInputStream("text.txt");
}
catch（FileNotFoundExcption e）
{ …… }
……
}
}
//消极处理方式 import java.io.*;
class ExceptionTest {
public static void main (string args[]) throws FileNotFoundExcption
{
FileInputStream fis=new FileInputStream("text.txt");
}
}
读入内容后：
package 异常; //积极处理方式
import java.io.*;
import java.io.BufferedReader;
import java.io.FileReader; class ExceptionTest {
public static void main (String args[])
{
File fis=new File("身份证号.txt");
try{ FileReader fr = new FileReader(fis);
BufferedReader br = new BufferedReader(fr);
try {
String s, s2 = new String();
while ((s = br.readLine()) != null) {
s2 += s + "\n ";
}
br.close();
System.out.println(s2);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}
package 异常; //消极处理方式 import java.io.*;
class ExceptionTest {
public static void main (String args[]) throws IOException
{
File fis=new File("身份证号.txt");
FileReader fr = new FileReader(fis);
BufferedReader br = new BufferedReader(fr);
String s, s2 = new String(); while ((s = br.readLine()) != null) {
s2 += s + "\n ";
}
br.close();
System.out.println(s2);
}
}
实验3: 编程练习
练习1：
1.编制一个程序，将身份证号.txt 中的信息读入到内存中；
2.按姓名字典序输出人员信息；
3.查询最大年龄的人员信息；
4.查询最小年龄人员信息；
5.输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
6.查询人员中是否有你的同乡；
在以上程序适当位置加入异常捕获代码。
package IDcard; import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Collections; public class ID { public static People findPeopleByname(String name) {
People flag = null;
for (People people : peoplelist) {
if(people.getName().equals(name)) {
flag = people;
}
}
return flag; } public static People findPeopleByid(String id) {
People flag = null;
for (People people : peoplelist) {
if(people.getnumber().equals(id)) {
flag = people;
}
}
return flag; } private static ArrayList<People> agenear(int yourage) {
// TODO Auto-generated method stub
int j=0,min=53,d_value=0,k = 0;
ArrayList<People> plist = new ArrayList<People>();
for (int i = 0; i < peoplelist.size(); i++) {
d_value = peoplelist.get(i).getage() > yourage ?
peoplelist.get(i).getage() - yourage : yourage - peoplelist.get(i).getage() ;
k = d_value < min ? i : k;
min = d_value < min ? d_value : min;
}
for(People people : peoplelist) {
if(people.getage() == peoplelist.get(k).getage()) {
plist.add(people);
}
}
return plist;
} private static ArrayList<People> peoplelist; public static void main(String[] args) //throws IOException
{
peoplelist = new ArrayList<People>();
Scanner scanner = new Scanner(System.in);
File file = new File("D:\\身份证号.txt");
try {
FileInputStream files = new FileInputStream(file);
BufferedReader in = new BufferedReader(new InputStreamReader(files));
String temp = null;
while ((temp = in.readLine()) != null) { String[] information = temp.split("[ ]+");
People people = new People();
people.setName(information[0]);
people.setnumber(information[1]);
int A = Integer.parseInt(information[3]);
people.setage(A);
people.setsex(information[2]);
for(int j = 4; j<information.length;j++) {
people.setplace(information[j]);
}
peoplelist.add(people); }
} catch (FileNotFoundException e) {
System.out.println("文件未找到");
e.printStackTrace();
} catch (IOException e) {
System.out.println("文件读取错误");
e.printStackTrace();
}
boolean isTrue = true;
while (isTrue) { System.out.println("******************************************");
System.out.println(" 1.按姓名典序输出人员信息");
System.out.println(" 2.查询最大年龄人员信息");
System.out.println(" 3.查询最小年龄人员信息");
System.out.println(" 4.输入你的年龄，查询身份证号.txt中年龄与你最近的人");
System.out.println(" 5.查询人员中是否有你的同乡");
System.out.println(" 6.退出");
System.out.println("******************************************");
int nextInt = scanner.nextInt();
switch (nextInt) {
case 1:
Collections.sort(peoplelist);
System.out.println(peoplelist.toString());
break;
case 2:
int max=0;
int j,k1 = 0;
for(int i=1;i<peoplelist.size();i++)
{
j = peoplelist.get(i).getage();
if(j>max)
{
max = j;
k1 = i;
} }
System.out.println("年龄最大："+peoplelist.get(k1));
break;
case 3:
int min = 100;
int j1,k2 = 0;
for(int i=1;i<peoplelist.size();i++)
{
j1 = peoplelist.get(i).getage();
if(j1<min)
{
min = j1;
k2 = i;
} }
System.out.println("年龄最小："+peoplelist.get(k2));
break;
case 4:
System.out.println("年龄：");
int input_age = scanner.nextInt();
ArrayList<People> plist = new ArrayList<People>();
plist = agenear(input_age);
for(People people : plist) {
System.out.println(people.toString());
}
break;
case 5:
System.out.println("请输入省份");
String find = scanner.next();
for (int i = 0; i <peoplelist.size(); i++)
{
String [] place = peoplelist.get(i).getplace().split("\t");
for(String temp : place) {
if(find.equals(temp)) {
System.out.println("你的同乡是 "+peoplelist.get(i));
break;
}
} }
break;
case 6:
isTrue = false;
System.out.println("byebye!");
break;
default:
System.out.println("输入有误");
}
}
} }
练习2：
1.编写一个计算器类，可以完成加、减、乘、除的操作；
2.利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
3.将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt；
4.在以上程序适当位置加入异常捕获代码。
程序如下：
package 算术题; import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner; public class ss {
public static void main(String[] args) { Scanner in = new Scanner(System.in);
sf sf=new sf();
PrintWriter output = null;
try {
output = new PrintWriter("ss.txt");
} catch (Exception e) {
//e.printStackTrace();
}
int sum = 0; for (int i = 1; i < 11; i++) {
int a = (int) Math.round(Math.random() * 100);
int b = (int) Math.round(Math.random() * 100);
int s = (int) Math.round(Math.random() * 4); switch(s)
{
case 1:
System.out.println(i+": "+a+"/"+b+"=");
while(b==0){
b = (int) Math.round(Math.random() * 100);
}
double c = in.nextDouble();
output.println(a+"/"+b+"="+c);
if (c == sf.chu_fa(a, b)) {
sum += 10;
System.out.println("恭喜答案正确");
}
else {
System.out.println("抱歉，答案错误");
} break; case 2:
System.out.println(i+": "+a+"*"+b+"=");
int c1 = in.nextInt();
output.println(a+"*"+b+"="+c1);
if (c1 == sf.chen_fa(a, b)) {
sum += 10;
System.out.println("恭喜答案正确");
}
else {
System.out.println("抱歉，答案错误");
}break;
case 3:
System.out.println(i+": "+a+"+"+b+"=");
int c2 = in.nextInt();
output.println(a+"+"+b+"="+c2);
if (c2 == sf.jia_fa(a, b)) {
sum += 10;
System.out.println("恭喜答案正确");
}
else {
System.out.println("抱歉，答案错误");
}break ;
case 4:
System.out.println(i+": "+a+"-"+b+"=");
int c3 = in.nextInt();
output.println(a+"-"+b+"="+c3);
if (c3 == sf.jian_fa(a, b)) {
sum += 10;
System.out.println("恭喜答案正确");
}
else {
System.out.println("抱歉，答案错误");
}break ; } }
System.out.println("成绩"+sum);
output.println("成绩:"+sum);
output.close(); }
}
package 算术题; public class sf
{
private int a;
private int b;
public int jia_fa(int a,int b)
{
return a+b;
}
public int jian_fa(int a,int b)
{
if((a-b)<0)
return 0;
else
return a-b;
}
public int chen_fa(int a,int b)
{
return a*b;
}
public int chu_fa(int a,int b)
{
if(b!=0)
return a/b;
else
return 0;
} }
结果如下：
实验4：断言、日志、程序调试技巧验证实验。
实验程序1：
//断言程序示例
public class AssertDemo {
public static void main(String[] args) {
test1(-5);
test2(-3);
} private static void test1(int a){
assert a > 0;
System.out.println(a);
}
private static void test2(int a){
assert a > 0 : "something goes wrong here, a cannot be less than 0";
System.out.println(a);
}
}
1.在elipse下调试程序AssertDemo，结合程序运行结果理解程序；
2.注释语句test1(-5);后重新运行程序，结合程序运行结果理解程序；
3.掌握断言的使用特点及用法。
程序运行结果如下：
注释后程序如下：
package stackTrace;
//断言程序示例
public class AssertDemo {
public static void main(String[] args) {
// test1(-5);
test2(-3);
} private static void test1(int a){
assert a > 0;
System.out.println(a);
}
private static void test2(int a){
assert a > 0 : "something goes wrong here, a cannot be less than 0";
System.out.println(a);
}
}
结果如下：
实验程序2：
1.用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；
2.并掌握Java日志系统的用途及用法。
程序如下：
package logging; import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.logging.*;
import javax.swing.*; /**
* A modification of the image viewer program that logs various events.
* @version 1.03 2015-08-20
* @author Cay Horstmann
*/
public class LoggingImageViewer
{
public static void main(String[] args)
{
if (System.getProperty("java.util.logging.config.class") == null
&& System.getProperty("java.util.logging.config.file") == null)
{
try
{
Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);
final int LOG_ROTATION_COUNT = 10;
Handler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);
Logger.getLogger("com.horstmann.corejava").addHandler(handler);
}
catch (IOException e)
{
Logger.getLogger("com.horstmann.corejava").log(Level.SEVERE,
"Can't create log file handler", e);
}
} EventQueue.invokeLater(() ->
{
Handler windowHandler = new WindowHandler();
windowHandler.setLevel(Level.ALL);
Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler); JFrame frame = new ImageViewerFrame();
frame.setTitle("LoggingImageViewer");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Logger.getLogger("com.horstmann.corejava").fine("Showing frame");
frame.setVisible(true);
});
}
} /**
* The frame that shows the image.
*/
class ImageViewerFrame extends JFrame
{
private static final int DEFAULT_WIDTH = 300;
private static final int DEFAULT_HEIGHT = 400; private JLabel label;
private static Logger logger = Logger.getLogger("com.horstmann.corejava"); public ImageViewerFrame()
{
logger.entering("ImageViewerFrame", "<init>");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); // set up menu bar
JMenuBar menuBar = new JMenuBar();
setJMenuBar(menuBar); JMenu menu = new JMenu("File");
menuBar.add(menu); JMenuItem openItem = new JMenuItem("Open");
menu.add(openItem);
openItem.addActionListener(new FileOpenListener()); JMenuItem exitItem = new JMenuItem("Exit");
menu.add(exitItem);
exitItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent event)
{
logger.fine("Exiting.");
System.exit(0);
}
}); // use a label to display the images
label = new JLabel();
add(label);
logger.exiting("ImageViewerFrame", "<init>");
} private class FileOpenListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
logger.entering("ImageViewerFrame.FileOpenListener", "actionPerformed", event); // set up file chooser
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File(".")); // accept all files ending with .gif
chooser.setFileFilter(new javax.swing.filechooser.FileFilter()
{
public boolean accept(File f)
{
return f.getName().toLowerCase().endsWith(".gif") || f.isDirectory();
} public String getDescription()
{
return "GIF Images";
}
}); // show file chooser dialog
int r = chooser.showOpenDialog(ImageViewerFrame.this); // if image file accepted, set it as icon of the label
if (r == JFileChooser.APPROVE_OPTION)
{
String name = chooser.getSelectedFile().getPath();
logger.log(Level.FINE, "Reading file {0}", name);
label.setIcon(new ImageIcon(name));
}
else logger.fine("File open dialog canceled.");
logger.exiting("ImageViewerFrame.FileOpenListener", "actionPerformed");
}
}
} /**
* A handler for displaying log records in a window.
*/
class WindowHandler extends StreamHandler
{
private JFrame frame; public WindowHandler()
{
frame = new JFrame();
final JTextArea output = new JTextArea();
output.setEditable(false);
frame.setSize(200, 200);
frame.add(new JScrollPane(output));
frame.setFocusableWindowState(false);
frame.setVisible(true);
setOutputStream(new OutputStream()
{
public void write(int b)
{
} // not called public void write(byte[] b, int off, int len)
{
output.append(new String(b, off, len));
}
});
} public void publish(LogRecord record)
{
if (!frame.isVisible()) return;
super.publish(record);
flush();
}
}
程序运行结果如下：
实验程序3：
1.用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；
2.按课件66-77内容练习并掌握Elipse的常用调试技术。
1）条件断点
添加断点：
点击Breakpoint Properties后：
2）变量断点
断点不仅能打在语句上，变量也可以接受断点：
上图就是一个变量的打的断点，在变量的值初 始化，或是变量值改变时可以停止，当然变量 断点上也是可以加条件的，和上面的介绍的条 件断点的设置是一样的。
3）方法断点
方法断点就是将断点打在方法的入口处：
方法断点的特别之处在于它可以打在JDK的源 码里，由于JDK在编译时去掉了调试信息，所 以普通断点是不能打到里面的，但是方法断点 却可以，可以通过这种方法查看方法的调用栈。
4）异常断点
经常遇见一些异常，然后程序就退出来了，要找到异常发生的地方就比较难了，还好可以打一个异常断点。
上图中我们增加了一个NullPointException的异常断点，当异常发生时，代码会停在异常发生处，定位问题时应该比较有帮助。
5）重新调试
6）单步执行程序
7）检查变量
8）改变变量值
第三部分：总结
通过本周的学习，我掌握了java异常处理的一些基础技术；通过调试理解书上的示例程序，再加上老师助、教学长的演示讲解，更好的使我理解这一章的知识。课后的自主编程也是在学长提供思路的基础上理解之后，补充完整的，本周除了惯例的编程练习外，重点是学习Java异常处理技术，更好的运用eclipse这个工具为我们编程提供服务。
王之泰201771010131《面向对象程序设计（java）》第九周学习总结的更多相关文章
- 20155312 2016-2017-2 《Java程序设计》第九周学习总结
20155312 2016-2017-2 <Java程序设计>第九周学习总结 课堂内容总结 两个类有公用的东西放在父类里. 面向对象的三要素 封装 继承 多态:用父类声明引用,子类生成对象 ...
- 20172325 2017-2018-2 《Java程序设计》第九周学习总结
20172325 2017-2018-2 <Java程序设计>第九周学习总结 教材学习内容总结 异常 1.学习了异常的基本概念: 2.区分异常与错误: 一个异常是指一个定义非正常情况或错误 ...
- 20155303 2016-2017-2 《Java程序设计》第九周学习总结
20155303 2016-2017-2 <Java程序设计>第九周学习总结 目录 学习内容总结(Linux命令) 教材学习中的问题和解决过程 代码调试中的问题和解决过程 代码托管 上周考 ...
- 20155321 2016-2017-2 《Java程序设计》第九周学习总结
20155321 2016-2017-2 <Java程序设计>第九周学习总结 教材学习内容总结 JDBC简介 厂商在实现JDBC驱动程序时,依方式可将驱动程序分为四种类型: JDBC-OD ...
- 20145302张薇《Java程序设计》第九周学习总结
20145302 <Java程序设计>第九周学习总结 教材学习内容总结 第十六周 JDBC简介 撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的增删查找 JDBC目的:让Jav ...
- 20145213《Java程序设计》第九周学习总结
20145213<Java程序设计>第九周学习总结 教材学习总结 "五一"假期过得太快,就像龙卷风.没有一点点防备,就与Java博客撞个满怀.在这个普天同庆的节日里,根 ...
- 21045308刘昊阳 《Java程序设计》第九周学习总结
21045308刘昊阳 <Java程序设计>第九周学习总结 教材学习内容总结 第16章 整合数据库 16.1 JDBC入门 16.1.1 JDBC简介 数据库本身是个独立运行的应用程序 撰 ...
- 20145337 《Java程序设计》第九周学习总结
20145337 <Java程序设计>第九周学习总结 教材学习内容总结 数据库本身是个独立运行的应用程序 撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的增删查找 JDBC可以 ...
- 《Java程序设计》第九周学习总结
20145224 <Java程序设计>第九周学习总结 第十六章 整合数据库 JDBC入门 ·数据库本身是个独立运行的应用程序 ·撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的 ...
- 20145236 《Java程序设计》第九周学习总结
20145236 <Java程序设计>第九周学习总结 教材学习内容总结 第十六章 整合数据库 JDBC简介 1.JDBC是java联机数据库的标准规范.它定义了一组标准类与接口,标准API ...
随机推荐
- Lucene入门学习二
接上篇:增删改查 增加:这里不做过多阐述. 删除:删除全部,根据条件删除 修该:先删除,后添加 查询(*):查询所有,精确查询,根据数值范围查询,组合查询,解析查询. package com.ithe ...
- 合并两个git仓库并保留提交记录
case如下: 有2个git仓库:repo1.repo2: 想将repo1中的文件移入repo2: repo1的历史日志要保留: 1 2 # 1.将repo1作为远程仓库,添加到repo2中,设置 ...
- vim 多窗口操作
1.打开多个窗口打开多个窗口的命令以下几个:横向切割窗口:new+窗口名(保存后就是文件名) :split+窗口名,也可以简写为:sp+窗口名纵向切割窗口名:vsplit+窗口名,也可以简写为:vsp ...
- HttpClient学习记录-系列2（源码学习）
如何阅读第三方工具源码? 存在多个入口,而且整个类图存在很多孤岛,自上而下的分析策略貌似不行,还是从use case入手,针对单个面分析.难点是如何做范围界定?不至于陷入黑洞 HttpGet -- ...
- 自己配置 vue 项目 知识体系(自己写脚手架 类似 vue-cli )
简单的目录结构: |-index.html |-main.js 入口文件 |-App.vue vue文件,官方推荐命名法 |-package.json 工程文件(项目依赖.名称.配置) npm ini ...
- 日志系统的 ELK 的搭建
https://www.cnblogs.com/yuhuLin/p/7018858.html 快速搭建ELK日志分析系统 一.ELK搭建篇 官网地址:https://www.elastic.co/cn ...
- CentOS使用systemctl daemon-reload报错Error getting authority: Error initializing authority: Error calling StartServiceByName for org.freedesktop.PolicyKit1: Timeout was reached (g-io-error-quark, 24)解决办法
CentOS修改了系统启动文件后需要重载报错 systemctl daemon-reload Error getting authority: Error initializing authority ...
- Docker命令详解（run篇）
命令格式:docker run [OPTIONS] IMAGE [COMMAND] [ARG...] Usage: Run a command in a new container 中文意思为:通过r ...
- ArcGIS API for JavaScript经典例子
地址为本地 1.绘制图形: http://localhost/arcgis_js_api/sdk/sandbox/sandbox.html?sample=toolbar_draw 2.双击编辑图形 h ...
- 深度学习基础（一）LeNet_Gradient-Based Learning Applied to Document Recognition
作者:Yann LeCun,Leon Botton, Yoshua Bengio,and Patrick Haffner 这篇论文内容较多,这里只对部分内容进行记录: 以下是对论文原文的翻译: 在传统 ...