Java复习之路（第十三天 异常 Io流）

最新推荐文章于 2024-06-09 20:28:45 发布
最新推荐文章于 2024-06-09 20:28:45 发布
阅读量99 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38214552/article/details/103844332
版权

Java基础

课前的复习内容：

  1. 继承
    1. 作用: 代码重用,复用
    2. 单继承
    3. 子类的实例
      1. 先创建父类实例
      2. 再创建子类实例
      3. 两个实例绑定,整体作为一个实例
      4. 调用成员时,先找子类再找父类
    4. 方法重写 Override
      1. 继承的方法,在子类中重新定义重新编写
    5. super
      1. super.xxxx()
        1. 重写时,调用父类中同一个方法的代码
      2. super(...)
        1. 调用父类的构造方法
        2. 默认 super()
        3. 手动 super(参数)
        4. 必须是首行代码

异常：

throw:

手动的进行抛出异常，执行异常抛出的动作，若没有出现错误，则会以return的形式进行正确的返回

自己进行创建异常的实例进行调用，涉及到错误信息的反馈的位置

package day1301_异常;

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		//进行异常的手动的抛出
		function();
	}

	public static void function() {
	System.out.println("请输入两个浮点数");
		double double1=new Scanner(System.in).nextDouble();
		double double2=new Scanner(System.in).nextDouble();
		//两个数相除的结果

		try {
			//将要有关异常运行的代码都要放进try的括号中进行处理
			double divide = divide(double1,double2);
			System.out.println(divide);
		} catch (ArithmeticException e) {
			//进行打印异常的信息
			e.printStackTrace();
			// 这里反馈给用户的信息
			System.out.println("除数不可以为零，请您原谅");
		}
	}

	public static double divide(double double1, double double2) {
		if (double2==0) {
			//括号里面的是反馈给程序员的，这是自己创建的异常的实例
			ArithmeticException e= new ArithmeticException("除数不可以为零");
			throw e;
		}
		return  double1/double2;	
	}
}

异常的包装

捕获的异常的实例：包装成为另外的实例在进行抛出

		try {
			
		} catch (AException e) {
			throw new BException(e)
		}

使用的场景：

不能抛出的异常，包装成为能抛出的类型继续抛出

简化异常，多种异常类型，进行简化为一种类型

方法的重写:

重写的方法的异常的管道，不可以比父类的方法多

练习：异常的包装

package day1301_异常;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

import javax.management.RuntimeErrorException;

public class Test2 {
	public static void main(String[] args) {
		function1();
	}

	public static void function1() {
		// 进行异常的包装
		ArrayList<String> arrayList=new ArrayList<>();
		Collections.addAll(arrayList, 
														"2019-6-3","2019-6-2","2019-6-15","2019-6-12","2019-6-29","2019-6-18","2019-6-2","2019-6-30","2019-6-3","2019-6-1");
		//上面的排序按照的是字符的排列的顺序
		Collections.sort(arrayList);
		System.out.println(arrayList);
		//进行重写比较器，可以直接在内部new出啦一分实例
		Collections.sort(arrayList,new Comparator<String>() {

			//进行实现他的抽象方法
			public int compare(String o1, String o2) {
				//按照日期的大小进行排序
				//String---SimpleDateFormat------>Date,作用就是将字符串转化为日期的类型
				//处理日期格式的工具
				//首相new出来一个实例，然后进行设定日期的格式
				SimpleDateFormat simpleDateFormat=
						//在这里大小写是有区别的，注意他的大小写的问题
													new SimpleDateFormat("yyyy-MM-dd");
				//先进行创建实例对象simpleDateFormat，利用创建出来的对对象进行将字符类型的数据转化为日期类型
				//用格式工具进行字符串的转化
				try {
					Date Date1 = simpleDateFormat.parse(o1);
					Date Date2 = simpleDateFormat.parse(o2);
					return Date1.compareTo(Date2);
				} catch (Exception e) {
					//一般的捕获异常，需要进行修复,但是在此处并不处理这一个异常，将异常继续抛出
					
					//进行包装成为可以进行抛出去，因为没有该方法的特殊的管道
					throw new RuntimeException(e);
				}
				//调用方法Date1.compareTo(Date2)进行日期的比较大小		
			}
		});
		System.out.println(arrayList);
	}
}

自定义异常：

现有的异常类型，需要表示具体的业务中的错误的情况，需要自定义一个新的异常的类型

自定义的异常：

起一个合适的类名---->继承一个合适的类名---->添加合适的构造的方法

练习：自定义异常

在这里进行要区分==和equals（）之间的区别

package day1301_异常;

import java.util.Scanner;

//进行测试自定义的异常
public class Test3 {
	public static void main(String[] args) {
		System.out.println("请你输入用户名");
		String userName = new Scanner(System.in).nextLine();
		System.out.println("请你输入密码 ");
		String passWord = new Scanner(System.in).nextLine();
		try {
			//进行判定用户名和密码是否正确
			login(userName,passWord);
			System.out.println("欢迎登陆");
		} catch (UsernameNotFoundException e) {
			System.out.println("你的用户名输入不正确，请重新输入");
		}catch (WrongPasswordException e) {
			System.out.println("你的密码输入不正确，请重新输入");
		}
	}
	//此方法没有默认的管道，是能自己进行添加管道，利用throws这一个关键字
	private static void login(String userName, String passWord) throws UsernameNotFoundException, WrongPasswordException {
		//进行检查用户名和密码  abc    123
		
		//自己书写错误的代码，在这里比较不乐意使用！=这一个符号
//		if (userName!="abc") {
//			throw new UsernameNotFoundException();
//		}
//		if (passWord!="123") {
//			throw new WrongPasswordException();
//		}
		
		if (!userName.equals("abc")) {
			throw new UsernameNotFoundException();
		}
		if (!passWord.equals("123")) {
			throw new WrongPasswordException();
		}
		
	}
}

创建的密码错误的类的方法，和选择继承的方法 （Exception和RuntimeException）常选用的继承的异常的父类

package day1301_异常;
//进行测试自定义的异常

//首先进行选择合适的父类异常进行选择
public class UsernameNotFoundException extends Exception{

	public UsernameNotFoundException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public UsernameNotFoundException(String message, Throwable cause, boolean enableSuppression,
			boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public UsernameNotFoundException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public UsernameNotFoundException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public UsernameNotFoundException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
	
}

 RuntimeException

Exception

检查异常，强制开发人员先考虑出现错误如何进行处理，编译器会检查时候添加了异常的处理代码，没有处理不能够被编译

RuntimeException

 非检查异常，有默认管道，编译器不检查这种异常

catch  和  throws

底层的异常，一般需要抛到上层处理，可以选择合适的卫视进行处理

经验不足时，首先选择的是throws

catch：进行异常的捕捉，进行处理

throws：将异常抛出

 

io流

input和output  输入/输出  文件的输入和输出是讲的Java是主要的人称，是对于内存数据来讲的

保存文件（输出）：程序执行时候，把内存中的数据，保存到存储器中（文件），代表的是输出

读取数据（输入）：从外部的存储器读取数据，把数据读入到内存中由程序来处理

 java.io

File  封装磁盘的路径的文件（文件、文件夹、不存在的路径都可以）

FileInputStream            FileOutputStream

ObjectInputStream       ObjectOutputStream

InputStreamReader      OutputStreamWriter

File的方法

文件或文件夹属性的方法

length()     getName()     getParent()     exists()     isFile()      idDirctory()

package day1302_File;

import java.io.File;

//进行测试File类
public class Test1 {
	public static void main(String[] args) {
		String path;
//		path="F:\\2019黑马附赠资料在D盘\\txs.txt";//存在的文件，双\\其中一个是转移符号的作用
		path="F:/2019黑马附赠资料在D盘";//存在的文件安夹,或者只单单的用一个/就可以
//		path="F:\\2019黑马附赠资料在D盘\\zxh";//不存在的路径
		//是将File文件进行封装文件
		//路径字符串封装到File实例
		File file=new File(path);
		System.out.println(file.getName());
		System.out.println(file.getParent());
		//显示他的绝对的路径，就是完整的路径
		System.out.println(file.getAbsolutePath());
		System.out.println(file.length());
		System.out.println(file.exists());
		System.out.println(file.isFile());
		//是否是文件夹
		System.out.println(file.isDirectory());
	}
}

创建或者是删除

creatNewFile()

新建的文件，不在进行创建，返回的是布尔的值,文件夹不存在，会出现异常

mkdirs()

逐层的进行创建多层文件夹

删除文件，或者是删除空的文件夹

package day1302_File;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class Test2 {
	/*
	 * 新建文件夹：F:\\abc\\aa\bb
	 * 新建文件夹：F:\\abc\\aa\bb\\f1
	 * 进行删除f1文件夹
	 * 进行删除bb文件夹
	 */
	//在这里进行添加文件的异常的管道
	public static void main(String[] args) throws IOException {
		System.out.println("请按回车键进行下一步的操作");
		//记忆文件和文件夹的创建的代码的书写
		//先将创建对象，然后调用对象的方法,完成文件或者是文件夹的创建
		new Scanner(System.in).nextLine();
		File dir=new File("F:\\abc\\aa\\bb");
		//这两行代码表示的是进行创建文件夹bb
		dir.mkdirs();
		
		new Scanner(System.in).nextLine();
		//直接将文件的路径进行写全
		File file = new File("F:\\abc\\aa\\bb\\f1");
		//或者是利用另外的一个多态的方法,父目录和文件以逗号隔开
		File file2 = new File(dir, "f1");
		file.createNewFile();
		file2.createNewFile();
		
		new Scanner(System.in).nextLine();
		file.delete();
		
		new Scanner(System.in).nextLine();
		file2.delete();
		
		new Scanner(System.in).nextLine();
		dir.delete();
	}
}

文件夹列表

list()

获取文件列表，string[]数组，只包含文件的名称的字符串

[“a.txt“]["b.jpg "]["c.abc"]

listFiles()

获取文件列表，File[]数组，包含每个文件得File对象,里面出来的包含文件的各种的属性

[{.......}{.......}{........}]

如果对文件夹，或者对不存在的路径，或无权进入的文件夹，会返回null值

package day1302_File;

import java.io.File;
import java.util.Scanner;

public class Test3 {
	public static void main(String[] args) {
		//
		System.out.println("输入文件夹");
		String string = new Scanner(System.in).nextLine();
		System.out.println("打印的是字符串的类型");
		//将对象封装称为文件夹
		File dir=new File(string);
		if(!dir.isDirectory()) {
			System.out.println("你输入的不是有效的路径");
			//try里面书写的是可以执行的代码块
			return;
		}else {
			//进行遍历文件夹里面的文件
			//遍历出来的是字符串的类型
			String[] names = dir.list();
		if(names==null) {
                        //这里面包含了三种情况，文件夹为空，文件夹不存在，或者是文件夹没有权限进行访问
			System.out.println("不可以获取文件的列表");
			return;	
		}
		else {
			//利用的是
			for(String name : names) {
				System.out.println(name);
			}
		}
		//打印的如果文件的形式，则输出的文件的全路径的形式
		System.out.println("打印的是文件的形式");
			//遍历出来的是文件的类型
			File[] listFiles = dir.listFiles();
			//将得到的文件进行遍历
			if (listFiles==null) {
				System.out.println("你搜索的文件夹为空");
				return;
			}else {
				for (File file : listFiles) {
					System.out.println(file);
				}
			}
		}
	}
}

练习：求文件夹的总大小（就是累加文文件夹里面的所有的文件的总大小，不一定只有一层的情况）

package day1302_File;

import java.io.File;
import java.util.Scanner;

//用到了方法的递归i
public class Test4 {
	public static void main(String[] args) {
		System.out.println("输入文件夹");
		String string = new Scanner(System.in).nextLine();
		System.out.println("打印的是字符串的类型");
		//将对象封装称为文件夹
		File dir=new File(string);
		if(!dir.isDirectory()) {
			System.out.println("你输入的不是有效的路径");
			//try里面书写的是可以执行的代码块
			return;
		}
		long size=dirLength(dir);
		System.out.println(size);
	}

	public static long dirLength(File dir) {

		File[] listFiles = dir.listFiles();
		if (listFiles==null) {
			//若选择的文件夹是空的，直接返回0
			return 0;
		}
		long sum=0;
		for (File file : listFiles) {
			if(file.isFile()) {
				//file是问价
				sum=sum+file.length();
			}else {
				//递归调用的方法书写(可以理解为方法进行调用自身的方法)
				//file是文件夹
				sum+=dirLength(file);
			}
		}
		return sum;
	}
}

流：Stream

把数据的读写，抽象成数据在管道中进行流动

简便的理解方法:读进来，写出去

读：把数据读出内存

写：把内存中的数据，向外部进行输出

单方向流动

输入流：只能进行从外部流入内存，只能用来读取数据

输出流：就是数据从内存中流出到外部设备，只能用来输出数据

数据从头到尾只能够进行流动一次，不能够进行反复的流动

FileInputStream：文件的输入流

FileOutputStream ：文件的输出流

这两个对象都是插在文件上的，读写文件的数据,直接的插在文件上的流，只有这一个文件流,其他的方法都是不可以的

方法：

write( int  b )

int是四个字节，

只输出字节，只输出末尾的一个字节值

write(byte[] ,start,  length)

就是进行指定的输出文件的字节，从start开始，长度是length的字节

read()

读取一个字节的值，在补三个字节0，转成int类型

read(byte[]  buff)

就是创建数组进行提高处理数据的速率，定义为数组的大小测试值是8096，buff就相当于自己在餐厅的饭盒一样，将buff工具交给方法。进行运算，若文件中的数据读取完成之后，在进行读取数据，会进行返回-1的形式进行警告

package day1401;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;

//进行测试文件流
public class Test1 {
	public static void main(String[] args) throws Exception {
		FileInputStream fileInputStream = new FileInputStream("F:\\abc\\f1");
		//进行创建批量处理的对象
		byte[] buff=new byte[5];
		int n;   //返回值来保存每一批的数量
		while ((n=fileInputStream.read(buff))!=-1) {
			System.out.println(n+"个："+Arrays.toString(buff));
		}
		System.out.println("------------------");
		//在read()括号里面的buff就相当于存储数据的饭盒
		n=fileInputStream.read(buff);
		System.out.println(n+"个："+Arrays.toString(buff));
		n=fileInputStream.read(buff);
		System.out.println(n+"个："+Arrays.toString(buff));
		n=fileInputStream.read(buff);
		System.out.println(n+"个："+Arrays.toString(buff));
		n=fileInputStream.read(buff);
		System.out.println(n+"个："+Arrays.toString(buff));
		n=fileInputStream.read(buff);
		System.out.println(n+"个："+Arrays.toString(buff));
		n=fileInputStream.read(buff);
		System.out.println(n+"个："+Arrays.toString(buff));
		
	}
}

读取结束，在进行读取数据，返回值为-1，进行警告

package day1303_字节流;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class Test1 {
	public static void main(String[] args) throws Exception {
		/*
		 * d:/abc/f1
		 * 
		 * --f1,进行插入管道
		 */
		FileOutputStream fileOutputStream = new FileOutputStream("F:\\abc\\f1");
		fileOutputStream.write(97);
		fileOutputStream.write(98);
		fileOutputStream.write(99);
		fileOutputStream.write(356);
		
		String [ ] a={
				"101","102","103","104","105","106","107","108","109","110"
		};
		byte  [ ] b= {
				101,102,103,104,105,106,107,108,109
		};
		fileOutputStream.write(b,0,6);
		//进行释放的系统的资源
		fileOutputStream.close();
	}
}

文件的加密，文件的解密：主要是更改文件的数据的顺序进行加密，然互还原顺序进行解密

算法的使用：对上面的数据进行异或处理，异或两次会还原原来的数据

练习：文件的加密,，就是涉及到文件的同时进行读写的操作

package day1303_字节流;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.Scanner;

public class Test3 {
	public static void main(String[] args) {
		//
		System.out.println("输入文件");
		String string = new Scanner(System.in).nextLine();
		//将输入的文件封装成为File
		File file=new File(string);
		//进行判定输入的file是不是文件
		if (!file.isFile()) {
			System.out.println("输入的不是文件");
			return;
		}
		System.out.println("请你输入要加密的Key：:");
		int Key=new Scanner(System.in).nextInt();
		try {
			/*
			 * 加密进行复制
			 * a.jpg---->"a.jpg".毫秒值
			 */
			
			//进行创建方法进行加密
			encryptCopy(file,Key);
			System.out.println("成功");
		} catch (Exception e) {
			System.out.println("失败");
			//进行打印完整的错误的信息
			e.printStackTrace();
		}
	}

	public static void encryptCopy(File file, int key) throws Exception {
		// 进行构建加密的方法，先将文件加密输入到内存，然后在将加密之后的数据从内存输出到外部的内存中
		//传进来的是源文件的父目录
		//原文件名.毫秒值
		File to=
				new File
				(file.getParentFile(),
				file.getName()+"."+System.currentTimeMillis());
		//创建文件的输入流，放在file身上
		FileInputStream fileInputStream = new FileInputStream(file);
		//创建文件的输出流，放在to身上
		FileOutputStream fileOutputStream = new FileOutputStream(to);
		int b;
		//从原文件中进行读取到加密到内存中
		while ((b=fileInputStream.read())!=-1){
			//将数据异或处理
			b^=key;
			//直接向目标文件进行输出
			fileOutputStream.write(b);
		}
		fileInputStream.close();
		fileOutputStream.close();	
	}
}

利用数租的提高数据的传送的速率：方法如下

 

 

 

 

 

 

 

 

 

 

 

 

Anoxia_Tian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day21 Java IO流 异常
m0_64350718的博客
02-16 511
异常 Java程序出现不正常的情况 异常的分类 Java中的异常：Throwable 严重的问题：Error，我们不处理，这样的问题一般都是很严重的，比如说内存溢出（OOM） 问题：Exception（异常）分为编译时期异常与运行时期异常 编译时期异常：除了RuntimeException都是编译时期异常，必须要处理，如果不处理，程序编译无法通过，无法运行 运行时期异常：RuntimeException，这样的问题，一般情况下，我们不会对问题本身进行处理，因为这样的问题是在自己写代码的过程中由
java学习21天之Io流
JOHON1的博客
09-13 199
含义:代表文件或文件夹作用:可以使用代码创建,删除,修改等文件操作使用:1,创建File对象pathName:文件路径uri:文件的资源定位符(统一资源定位符 也被称为)File(File parent,Sring child) parent:文件或文件夹的上一级文件夹 child:当前文件或文件夹名称(要加后缀)File(String parent,String child) parent:文件或文件夹的上一级文件夹路径 child:当前文件或文件夹名称(要加后缀)
Java复习之路（第十四天 io+多线程）
qq_38214552的博客
01-06 141
Java基础 回顾： 抽象类 半成品,没有完成的类,不能进行创建实例 抽象方法的作用: 作为通用方法在父类中定义 要求子类必须实现 final 常量,不可变，创建以后不可以进行改变他的值，就是一个最重的数值 方法,不能重写 类,不能继承 static 静态属于类,而不属于实例 使用场景: 共享的数据 工具方法 Math.sqrt()...
Java-13_File类与IO流
最新发布
m0_62036548的博客
06-09 677
File类及各种流，都定义在java.io包下。一个File对象代表硬盘或网络中可能存在的一个文件或者文件目录（文件夹），与平台无关。File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。访问文件内容本身，需要使用输入/输出流。File对象可以作为参数传递给流的构造器。Java程序中表示一个真实存在的文件或目录，必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
Java语言程序设计基础第十版第十二章课后复习题答案
06-26
根据提供的信息，我们可以总结出以下关于《Java语言程序设计基础第十版》第十二...以上是对《Java语言程序设计基础第十版》第十二章中部分复习题答案的详细解释，希望能帮助读者更好地理解Java中的异常处理及相关概念。
计算机后端-Java-Java核心基础30天全套教程7_每日一考与复习第1部分：Java基础编程.zip
05-21
这个"计算机后端-Java-Java核心基础30天全套教程7_每日一考与复习第1部分：Java基础编程.zip"文件集合，显然是为了帮助学习者系统地掌握Java的基础编程技能。以下是基于这个主题的详细知识点解析： 1. **Java简介**...
java复习
qq_48257021的博客
03-31 1082
将一个类声明为final，则可以将它的内容、属性和功能固定下来，与它的类名形成稳定的映射关系，从而保证引用这个类时所实现功能的正确无误。在使用中，接口类的变量可以用来代表任何实现了该接口的类的对象，这就相当于把类根据其实现的功能来分别代表，而不必顾虑它所在的类继承层次。机器语言和汇编语言几乎没有抽象，对于机器而言是最合适的描述，它可以直接操作机器的硬件，并且任何操作都是面向机器的，这就要求人们在使用机器语言或汇编语言编写程序时，必须按照机器的方式去思考问题。变量的作用域指可以访问该变量的程序代码范围。
Java复习之路（第二十五天 cookie和session）
qq_38214552的博客
01-20 332
Java基础 会话：从打开浏览器访问服务器开始，到最后关闭浏览器，访问服务区停止为止，这期间产生的多次的请求和响应加在一起，就称之为浏览器和服务器之间的一次会话 再一次会话中往往会产生一些数据，而这些数据往往需要我们保存起来，如何用来保存会话中产生的数据？ 可以使用会话的技术中的cookie或者session Cookie: cookie保存数据的原理： 1.cookie是将会话中...
JAVA复习题库.pdf
10-03
第十三部分：Java 语言的历史 1. Java 语言最初是面向消费电子产品设计的。 2. Java 语言是以 C++ 语言为基础的。 第十四部分：Java 语言的核心包 1. Java 语言的核心包是指 JDK 中的 java.lang、java.util、java...
Java复习之路（第二十三天 jsp）
qq_38214552的博客
01-18 391
Java基础 jsp概述 JSP是由SUN公司提供的一门动态Web资源开发技术JSP看起来像一个HTML，但和html不同的是，JSP中可以书写Java代码，可以通过Java代码获取动态的数据。所以JSP可以开发动态网页。JSP其实本质上就是一个Servlet程序,jsp是动态的网页开发技术 为什么要学习jsp： Servlet本质上是一段Java程序，擅长处理业务逻辑，但是不适合向外输出...
Java复习之路（第二十六天 mybatis ）
qq_38214552的博客
01-21 362
Java基础（框架） 什么是mybatis： MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而...
Java复习之路（第二十一天 JavaScript）
qq_38214552的博客
01-14 283
Java基础 永和大王项目的实现： 代码块的实现：（注意：再引用相关的网页的时候，需要将网页放在同一个文件夹下面，测试的网页才能找到） 主代码部分 <! doctype html> <html> <head> <title></title> <meta charset='utf-8'> </head...
Java复习之路（第十二天 集合HashMap 异常）
qq_38214552的博客
01-04 243
Java基础 接口 Collection:接口 List 接口 Set 接口 Map 接口 HashMap:哈希表 存放键值对的数据 可以利用键快速的进行查找数据 方法：进行存放数据： 键：不重复 无序 必须进行同时重写hashCode()和equals...
Java复习之路（第十六天 Java高级基础知识）
qq_38214552的博客
01-07 233
Java高级基础知识 注解：一统江湖，主流的开发的开发到的方式：注解的方式、 反射reflect：Hello.java编译后为Hello.class 字节码文件二进制文件。以后三大框架SpringMVC Spring Mybatis他们的底层工作的原理，很多就是基于反射，先写会api调用 控制反转：万物皆对象,传统的方式：new User(),控制反转它来创建对象，管理对象，你可以...
Java复习之路（第二十七天 Spring和Springmvc）
qq_38214552的博客
01-30 214
Java基础知识（spring+springMVC） 初识spring框架 spring简介： 1、Spring是一个开源的轻量级的应用开发框架，其目的是用于简化企业级应用程序开发，降低开发者的开发难度；(简化开发：spring对常用的api，比如对JDBC做了封装，使用spring封装的jdbc访问数据库，就不用考虑获取连接、关闭连接等，极大的简化了代码) 2、Sprin...
Java复习之路（第二十八天 永和项目）
qq_38214552的博客
01-30 210
Java基础知识
Java复习之路（第二十天 HTML+CSS）
qq_38214552的博客
01-12 204
网页编程基础-HTML HTML是什么 HTML(Hyper Text Markup Language ): 超文本标记语言，是开发网页的最基础的语言由W3C组织提供 关于HTML: (1) HTML是一门标记(也叫做标签或元素)语言，不是编程语言 (2) HTML是一门标记语言，是利用标记来组织网页结构的 (3) 使用html开发的网页文件，以".html"或".htm "（.s...
双元教育（第二天）
qq_38214552的博客
12-28 183
双元教育 目录 面向对象概念复习 类和对象 构造器和静态工厂 对象的创建和引用 关键字 类间关系 Object类 抽象类与接口 面向对象概念复习 面向对象开发的终级目的：代码复用。 面向对象开发是大规模开发的必然产物。 现实世界中类与对象是个体与整体的关系；在计算机世界中类与对象抽象与具体的关系。 计算机世界中的类是抽...
Java理论知识复习：判断与选择题解析
13. URL对象：URL对象一旦创建，其地址不可修改，第十三题的描述错误。 14. 端口号：在互联网中，每个端口号在同一时间在一个特定IP地址上只能被一个服务使用，第十四题的描述不正确。 15. 网络协议与IP地址：在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值