Java入门
学习视频:https://www.imooc.com/learn/110
内容简介
第1章 异常与异常处理
本章主要讲解,什么是异常、Java 中的异常体系结构、如何处理异常、如何自定义异常以及异常链的相关知识
第2章 认识 Java 中的字符串
本章节主要讲解 Java 中的字符串,字符串被广泛地用在 Java 程序设计中,很多操作都要使用字符串来完成,例如系统中存储的用户名、密码、电子邮箱等都要使用字符串来存储。学完这一章后能够掌握字符串的处理, String 类和 StringBuilder 类常用方法的应用等
第3章 Java 中必须了解的常用类
本章节主要讲解 Java 中常用的类,包括基本类型的包装类、Date 类、SimpleDateFormat 类、 Calendar 类、 Math 类。学完这一章后将对基本数据类型有更深入的理解,能够进行基本类型和包装类之间的转换,掌握常用类的使用等
第4章 Java 中的集合框架(上)
本章主要讲解,什么是集合,Java集合框架的体系结构和集合的作用,以及常用的集合类—— ArrayList、HashSet 的讲解与实际应用。
第5章 Java 中的集合框架(中)
本章主要讲解,Java集合框架中的 Map 接口及其实现类的应用
第6章 Java 中的集合框架(下)
本章主要讲解,集合框架中复杂查询方法的应用、集合算法类 Collections 的应用,以及如何通过 Comparable 和 Comparator 接口进行对象的比较
第1章 异常与异常处理
1.java异常简介
Error和Exception是Throwable的子类,其详细关系如下:
Error(程序基本挂掉)
Exception
非检查异常
检查异常
2.java异常处理
1.Java中使用try…catch…fi…
try-catch以及try-catch-finally
try{
//一些会抛出异常的方法
}catch(Exception e){
//处理该异常的代码块
}
如下:
try{
System.out.print("请输入你的年龄:");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
System.out.println("十年后你"+(age+10)+"岁");
}catch(InputMismatchException e){
System.out.println("你应该输入整数");
}
System.out.println("程序结束啦");
catch多重语句
应该以先子类后父类的顺序编写catch语句
try{
//一些会抛出异常的方法
}catch(Exception e){
//处理该异常的代码块
}catch(Exception2 e){
//处理该异常2的代码块
}...(n个catch块)...{
}finally{
//最终将要执行的一些的代码
}
2.Java中的异常抛出以及自定义异常
1.异常抛出
2.自定义异常
虽然Java系统已经预定义好了很多异常类,但是有时会遇到预定义的异常类不能描述出现的错误。在这种情况下,程序员可以通过扩展Exception类及其子类来定义自己的异常类。
格式如下:
class 自定义异常类 extends 异常类型{
}
实例:
public class DrunkException extends Exception {
public DrunkException(){
}
public DrunkException(String message){
super(message);
}
}
3.Java中的异常链
把捕获的异常包装成一个新的异常,在新的异常中添加对新的异常的引用,再把新异常抛出,就像是链式反应一样,这种就叫异常链。
实例:
public class ChainTest{
/**
* test1():抛出“喝大了”异常
* test2():调用test1(),捕获“喝大了”异常,并且包装成运行时异常,继续抛出
* main方法中,调用test2(),尝试捕获test2()方法抛出的异常
*/
public static void main(String[] args) {
ChainTest ct = new ChainTest();
try{
ct.test2();
}catch(Exception e){
e.printStackTrace();
}
}
public void test1() throws DrunkException{
throw new DrunkException("喝车别开酒!");
}
public void test2(){
try {
test1();
} catch (DrunkException e) {
// TODO Auto-generated catch block
RuntimeException newExc =
new RuntimeException(e);
// newExc.initCause(e);
throw newExc;
}
}
}
第2章 认识 Java 中的字符串
什么是 Java 中的字符串
在程序开发中字符串无处不在,如用户登陆时输入的用户名、密码等使用的就是字符串。
在 Java 中,字符串被作为 String 类型的对象处理。 String 类位于 java.lang 包中。默认情况下,该包被自动导入所有的程序。
实例:
public class HelloWorld {
public static void main(String[] args) {
//定义字符串
String hobby = "什么是 Java 中的字符串";
String url = " Java 中的字符串";
//输出字符串
System.out.println("hobby:" + hobby );
System.out.println("url:" + url );
}
}
Java 中字符串的不变性
String 对象创建后则不能被修改,是不可变的,所谓的修改其实是创建了新的对象,所指向的内存空间不同。如下所示:
public class HelloWorld {
String s1 = "imooc";
String s2 = "imooc";
String s3 = "I love" + s1;
//定义字符串s3,保存“I love”和s1拼接后的内容
// 比较字符串s1和s2
// imooc为常量字符串,多次出现时会被编译器优化,只创建一个对象
System.out.println("s1和s2内存地址相同吗?" + (s1 == s2));
//比较字符串s1和s3
System.out.println("s1和s3内存地址相同吗?" + (s1 == s3) );
String s4 = "I love " + s1;
//比较字符串s4和s3
// s1是变量,s4在运行时才知道具体值,所以s3和s4是不同的对象
System.out.println("s3和s4内存地址相同吗?" + (s4 == s3));
}
}
String 类的常用方法
认识 Java 中的 StringBuilder 类
在Java中,除了可以使用 String 类来存储字符串,还可以使用 StringBuilder 类或 StringBuffer 类存储字符串,那么它们之间有什么区别呢?
String 类具有是不可变性。如
public class HelloWorld {
public static void main(String[] args) {
// 创建一个StringBuilder对象,用来存储字符串
StringBuilder hobby=new StringBuilder("爱慕课");
System.out.println(hobby);
}
}
Java 中的 StringBuilder 类的常用方法
第3章 Java 中必须了解的常用类
Java 中的包装类
基本类型和包装类之间的对应关系:
实例:
public static void main(String[] args) {
// 定义int类型变量,值为86
int score1 = 86;
// 创建Integer包装类对象,表示变量score1的值
Integer score2=new Integer(score1);
// 将Integer包装类转换为double类型
double score3=score2.doubleValue();
// 将Integer包装类转换为float类型
float score4=score2.floatValue();
// 将Integer包装类转换为int类型
int score5 =score2.intValue();
System.out.println("Integer包装类:" + score2);
System.out.println("double类型:" + score3);
System.out.println("float类型:" + score4);
System.out.println("int类型:" + score5);
}
}
Java 中基本类型和包装类之间的转换
装箱:把基本类型转换成包装类,使其具有对象的性质,又可分为手动装箱和自动装箱
拆箱:和装箱相反,把包装类对象转换成基本类型的值,又可分为手动拆箱和自动拆箱
实例:
public class HelloWorld {
public static void main(String[] args) {
// 定义double类型变量
double a = 91.5;
// 手动装箱
Double b = new Double(a);
// 自动装箱
Double c = a;
System.out.println("装箱后的结果为:" + b + "和" + c);
// 定义一个Double包装类对象,值为8
Double d = new Double(87.0);
// 手动拆箱
double e = d.doubleValue();
// 自动拆箱
double f = d;
System.out.println("拆箱后的结果为:" + e + "和" + f);
}
}
Java 中基本类型和字符串之间的转换
基本类型转换为字符串有三种方法:
- 使用包装类的 toString() 方法
- 使用String类的 valueOf() 方法
- 用一个空字符串加上基本类型,得到的就是基本类型数据对应的字符串
字符串转换成基本类型有两种方法:
- 调用包装类的 parseXxx 静态方法
- 调用包装类的 valueOf() 方法转换为基本类型的包装类,会自动拆箱
使用 Math 类操作数据
第4章 Java 中的集合框架
Java 中的集合框架 (Collection接口&List接口)
集合的作用
从架构的方面来理解,可能稍微容易一点.
在编程中,需要管理很多对象集.比如某班全copy部同学,某个公司所有人员资料等.
要管理这些资料,java必须提供某种数据结构支持.
由于时间,空间,安全的考虑,有各种不同的实现.比如ArrayList,vector.hashmap,linklist,treemap,hashset等多种实现.
为了屏蔽实现差异,java提供了一个Collection(集合)接口,规定必须实现一些公用的方法.
比如 add.remove,size等等这样,不管底层如何实现,我都知道他们至zd少拥有上面方法.
一句话java集合就是提供一组通用接口的,管理大量数据的数据结构实现.
两大家族:Collection和Map
学生选课—创建学生类和课程类
创建学生类
import java.util.HashSet;
import java.util.Set;
/**
* 学生类
* @author Administrator
*
*/
public class Student {
public String id;
public String name;
public Set<Course> courses;
public Student(String id, String name) {
this.id = id;
this.name = name;
this.courses = new HashSet<Course>();
}
}
创建课程类
/**
* 课程类
* @author Administrator
*
*/
public class Course {
public String id;
public String name;
public Course(String id, String name) {
this.id = id ;
this.name = name;
}
public Course() {
}
}
学生选课—增删改查
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 备选课程类
* @author Administrator
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
this.coursesToSelect = new ArrayList();
}
/**
* 用于往coursesToSelect中添加备选课程
*/
public void testAdd() {
//创建一个课程对象,并通过调用add方法,添加到备选课程List中
Course cr1 = new Course("1" , "数据结构");
coursesToSelect.add(cr1);
Course temp = (Course) coursesToSelect.get(0);
System.out.println("添加了课程:" + temp.id + ":" + temp.name);
Course cr2 = new Course("2", "C语言");
coursesToSelect.add(0, cr2);
Course temp2 = (Course) coursesToSelect.get(0);
System.out.println("添加了课程:" + temp2.id + ":" + temp2.name);
coursesToSelect.add(cr1);
Course temp0 = (Course) coursesToSelect.get(2);
System.out.println("添加了课程:" + temp.id + ":" + temp.name);
//以下方法会抛出数组下标越界异常
// Course cr3 = new Course("3", "test");
// coursesToSelect.add(4, cr3);
Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 = (Course) coursesToSelect.get(2);
Course temp4 = (Course) coursesToSelect.get(3);
System.out.println("添加了两门课程:" + temp3.id + ":" +
temp3.name + ";" + temp4.id + ":" + temp4.name);
Course[] course2 = {new Course("5", "高等数学"), new Course("6", "大学英语")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp5 = (Course) coursesToSelect.get(2);
Course temp6 = (Course) coursesToSelect.get(3);
System.out.println("添加了两门课程:" + temp5.id + ":" +
temp5.name + ";" + temp6.id + ":" + temp6.name);
}
/**
* 取得List中的元素的方法
* @param args
*/
public void testGet() {
int size = coursesToSelect.size();
System.out.println("有如下课程待选:");
for(int i= 0 ; i < size; i++) {
Course cr = (Course) coursesToSelect.get(i);
System.out.println("课程:" + cr.id + ":" + cr.name);
}
}
/**
* 通过迭代器来遍历List
* @param args
*/
public void testIterator() {
//通过集合的iterator方法,取得迭代器的实例
Iterator<Course> it = coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问):");
while(it.hasNext()) {
Course cr = it.next();
System.out.println("课程:" + cr.id + ":" + cr.name);
}
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问):");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程:" + cr.id + ":" + cr.name);
}
}
/**
* 修改List中的元素
* @param args
*/
public void testModify() {
coursesToSelect.set(4, new Course("7", "毛概"));
}
/**
* 删除List中的元素
* @param args
*/
public void testRemove() {
// Course cr = (Course) coursesToSelect.get(4);
System.out.println("即将删除4位置和5位置上的课程!");
Course[] courses = {(Course) coursesToSelect.get(4), (Course)coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));
// coursesToSelect.remove(4);
System.out.println("成功删除课程!");
testForEach();
}
/**
* 往List中添加一些奇怪的东西
* @param args
*/
public void testType() {
System.out.println("能否往List中添加一些奇怪的东西呢!?");
coursesToSelect.add("我不是课程,我只是一个无辜的字符串!!");
}
public static void main( String[] args) {
ListTest lt = new ListTest();
lt.testAdd();
lt.testType();
lt.testForEach();
// lt.testGet();
// lt.testIterator();
// lt.testForEach();
// lt.testModify();
// lt.testForEach();
// lt.testRemove();
}
}
学生选课—应用泛型管理课程
import java.util.ArrayList;
import java.util.List;
public class TestGeneric {
/**
* 带有泛型——Course,的List类型属性
*/
public List<Course> courses;
public TestGeneric() {
this.courses = new ArrayList<Course>();
}
/**
* 测试添加
*/
public void testAdd() {
Course cr1 = new Course("1","大学语文");
courses.add(cr1);
//泛型集合中,不能添加泛型规定的类型及其子类型以外的对象,否则会报错!
// courses.add("能否添加一些奇怪的东西呢??");
Course cr2 = new Course("2","Java基础");
courses.add(cr2);
}
/**
* 测试循环遍历
*/
public void testForEach() {
for (Course cr : courses) {
System.out.println(cr.id + ":" + cr.name);
}
}
/**
* 泛型结合可以添加泛型的子类型的对象实例
*/
public void testChild() {
ChildCourse ccr = new ChildCourse();
ccr.id = "3";
ccr.name = "我是子类型的课程对象实例~~";
courses.add(ccr);
}
/**
* 泛型不能使用基本类型
*/
public void testBasicType() {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
System.out.println("基本类型必须使用包装类作为泛型!" + list.get(0));
}
/**
* @param args
*/
public static void main(String[] args) {
TestGeneric tg = new TestGeneric();
tg.testAdd();
tg.testForEach();
tg.testChild();
tg.testForEach();
tg.testBasicType();
}
}
public class ChildCourse extends Course {
}
学生选课—通过Set管理课程
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class SetTest {
public List<Course> coursesToSelect;
public SetTest() {
coursesToSelect = new ArrayList<Course>();
}
/**
* 用于往coursesToSelect中添加备选课程
*/
public void testAdd() {
// 创建一个课程对象,并通过调用add方法,添加到备选课程List中
Course cr1 = new Course("1", "数据结构");
coursesToSelect.add(cr1);
Course temp = (Course) coursesToSelect.get(0);
// System.out.println("添加了课程:" + temp.id + ":" + temp.name);
Course cr2 = new Course("2", "C语言");
coursesToSelect.add(0, cr2);
Course temp2 = (Course) coursesToSelect.get(0);
// System.out.println("添加了课程:" + temp2.id + ":" + temp2.name);
// coursesToSelect.add(cr1);
// Course temp0 = (Course) coursesToSelect.get(2);
// System.out.println("添加了课程:" + temp.id + ":" + temp.name);
// 以下方法会抛出数组下标越界异常
// Course cr3 = new Course("3", "test");
// coursesToSelect.add(4, cr3);
Course[] course = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 = (Course) coursesToSelect.get(2);
Course temp4 = (Course) coursesToSelect.get(3);
// System.out.println("添加了两门课程:" + temp3.id + ":" +
// temp3.name + ";" + temp4.id + ":" + temp4.name);
Course[] course2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp5 = (Course) coursesToSelect.get(2);
Course temp6 = (Course) coursesToSelect.get(3);
// System.out.println("添加了两门课程:" + temp5.id + ":" +
// temp5.name + ";" + temp6.id + ":" + temp6.name);
}
/**
* 通过for each方法访问集合元素
*
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问):");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程:" + cr.id + ":" + cr.name);
}
}
/**
* @param args
*/
public static void main(String[] args) {
SetTest st = new SetTest();
st.testAdd();
st.testForEach();
// 创建一个学生对象
Student student = new Student("1", "小明");
System.out.println("欢迎学生:" + student.name + "选课!");
// 创建一个Scanner对象,用来接收从键盘输入的课程ID
Scanner console = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入课程ID");
String courseId = console.next();
for (Course cr : st.coursesToSelect) {
if (cr.id.equals(courseId)) {
student.courses.add(cr);
/**
* Set中,添加某个对象,无论添加多少次, 最终只会保留一个该对象(的引用), 并且,保留的是第一次添加的那一个
*/
// student.courses.add(null);
student.courses.add(cr);
}
}
}
st.testForEachForSet(student);
}
public void testForEachForSet(Student student) {
// 打印输出,学生所选的课程!
System.out.println("共选择了:" + student.courses.size() + "门课程!");
for (Course cr : student.courses) {
System.out.println("选择了课程:" + cr.id + ":" + cr.name);
}
}
}
Java 中的集合框架 (Map&HashMap)
代码如下:
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class MapTest {
/**
* 用来承装学生类型对象
*/
public Map<String, Student> students;
/**
* 在构造器中初始化students属性
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加:输入学生ID,判断是否被占用 若未被占用,则输入姓名,创建新学生对象,并且 添加到students中
*/
public void testPut() {
// 创建一个Scanner对象,用来获取输入的学生ID和姓名
Scanner console = new Scanner(System.in);
int i = 0;
while (i < 3) {
System.out.println("请输入学生ID:");
String ID = console.next();
// 判断该ID是否被占用
Student st = students.get(ID);
if (st == null) {
// 提示输入学生姓名
System.out.println("请输入学生姓名:");
String name = console.next();
// 创建新的学生对象
Student newStudent = new Student(ID, name);
// 通过调用students的put方法,添加ID-学生映射
students.put(ID, newStudent);
System.out.println("成功添加学生:" + students.get(ID).name);
i++;
} else {
System.out.println("该学生ID已被占用!");
continue;
}
}
}
/**
* 测试Map的keySet方法
*/
public void testKeySet() {
// 通过keySet方法,返回Map中的所有“键”的Set集合
Set<String> keySet = students.keySet();
// 取得students的容量
System.out.println("总共有:" + students.size() + "个学生!");
// 遍历keySet,取得每一个键,再调用get方法取得每个键对应的value
for (String stuId : keySet) {
Student st = students.get(stuId);
if (st != null)
System.out.println("学生:" + st.name);
}
}
/**
* 测试删除Map中的映射
*/
public void testRemove() {
// 获取从键盘输入的待删除学生ID字符串
Scanner console = new Scanner(System.in);
while (true) {
// 提示输入待删除的学生的ID
System.out.println("请输入要删除的学生ID!");
String ID = console.next();
// 判断该ID是否有对应的学生对象
Student st = students.get(ID);
if (st == null) {
// 提示输入的ID并不存在
System.out.println("该ID不存在!");
continue;
}
students.remove(ID);
System.out.println("成功删除学生:" + st.name);
break;
}
}
/**
* 通过entrySet方法来遍历Map
*/
public void testEntrySet() {
// 通过entrySet方法,返回Map中的所有键值对
Set<Entry<String, Student>> entrySet = students.entrySet();
for (Entry<String, Student> entry : entrySet) {
System.out.println("取得键:" + entry.getKey());
System.out.println("对应的值为:" + entry.getValue().name);
}
}
/**
* 利用put方法修改Map中的已有映射
*/
public void testModify() {
// 提示输入要修改的学生ID
System.out.println("请输入要修改的学生ID:");
// 创建一个Scanner对象,去获取从键盘上输入的学生ID字符串
Scanner console = new Scanner(System.in);
while (true) {
// 取得从键盘输入的学生ID
String stuID = console.next();
// 从students中查找该学生ID对应的学生对象
Student student = students.get(stuID);
if (student == null) {
System.out.println("该ID不存在!请重新输入!");
continue;
}
// 提示当前对应的学生对象的姓名
System.out.println("当前该学生ID,所对应的学生为:" + student.name);
// 提示输入新的学生姓名,来修改已有的映射
System.out.println("请输入新的学生姓名:");
String name = console.next();
Student newStudent = new Student(stuID, name);
students.put(stuID, newStudent);
System.out.println("修改成功!");
break;
}
}
/**
* @param args
*/
public static void main(String[] args) {
MapTest mt = new MapTest();
mt.testPut();
mt.testKeySet();
// mt.testRemove();
// mt.testEntrySet();
// mt.testModify();
// mt.testEntrySet();
}
}