一、基础语法
1.数据类型
2.类型转换
(1)自动类型转换
(2)强制类型转换(有可能会数据丢失)
3.运算符(普通运算符类似数学中的运算符)
条件运算符
运算符优先级
3.数组
1、 声明数组
语法: 数据类型[ ] 数组名;
或者 数据类型 数组名[ ];
其中,数组名可以是任意合法的变量名,如:
2、 分配空间
简单地说,就是指定数组中最多可存储多少个元素
语法: 数组名 = new 数据类型 [ 数组长度 ];
其中,数组长度就是数组中能存放元素的个数,如:
话说,我们也可以将上面的两个步骤合并,在声明数组的同时为它分配空间,如:
3、 赋值
分配空间后就可以向数组中放数据了,数组中元素都是通过下标来访问的,例如向 scores 数组中存放学生成绩
4、 处理数组中数据
我们可以对赋值后的数组进行操作和处理,如获取并输出数组中元素的值
在 Java 中还提供了另外一种直接创建数组的方式,它将声明数组、分配空间和赋值合并完成,如
它等价于:
4.foreach语法
二、类与对象
1.static
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
程序运行时静态初始化块最先被执行,然后执行普通初始化块,最后才执行构造方法。由于静态初始化块只在类加载时执行一次。
2.内部类
内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。
内部类的主要作用如下:
1. 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
内部类可分为以下几种:
- 成员内部类
- 静态内部类
- 方法内部类
- 匿名内部类
HelloWorld hello = new HelloWorld();
// 创建内部类对象
Inner i = hello.new Inner();
创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名= new 内部类();
3.字符串
String 对象创建后则不能被修改,是不可变的,所谓的修改其实是创建了新的对象,所指向的内存空间不同。如下所示:
String 类的常用方法:
StringBuffer 是线程安全的,而 StringBuilder 则没有实现线程安全功能,所以性能略高。
StringBuilder 类提供了很多方法来操作字符串:
在程序开发中,我们经常需要在基本数据类型和字符串之间进行转换。
其中,基本类型转换为字符串有三种方法:
1. 使用包装类的 toString() 方法
2. 使用String类的 valueOf() 方法
3. 用一个空字符串加上基本类型,得到的就是基本类型数据对应的字符串
再来看,将字符串转换成基本类型有两种方法:
1. 调用包装类的 parseXxx 静态方法
2. 调用包装类的 valueOf() 方法转换为基本类型的包装类,会自动拆箱
使用 parse() 方法将文本转换为日期
使用 format() 方法将日期转换为指定格式的文本
常用的方法:
二、集合框架
ListTest
package testCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Iterator;
public class ListTest {
public List coursesToSelect;
public ListTest() {
this.coursesToSelect = new ArrayList();
}
/*往List中添加元素*/
public void Add() {
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 temp1 =(Course)(coursesToSelect.get(0));
System.out.println("添加了课程:" + temp1.id + ":" + temp1.name);
//以下会产生数组越界异常
// Course cr3 = new Course("3","C++");
// coursesToSelect.add(3, cr3);
Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 =(Course)coursesToSelect.get(2);
System.out.println("添加了课程:" + temp3.id + ":" + temp3.name);
Course temp4 =(Course)coursesToSelect.get(3);
System.out.println("添加了课程:" + temp4.id + ":" + temp4.name);
Course[] course1 = {new Course("5","机器学习"),new Course("6","计算机网络")};
coursesToSelect.addAll(2,Arrays.asList(course1));
Course temp5 =(Course)coursesToSelect.get(2);
System.out.println("添加了课程:" + temp5.id + ":" + temp5.name);
Course temp6 =(Course)coursesToSelect.get(3);
System.out.println("添加了课程:" + temp6.id + ":" + temp6.name);
}
/**
* 取出List中的元素*/
public void testGet() {
int size = coursesToSelect.size();
for (int i=0;i<size;i++) {
Course cr = (Course)coursesToSelect.get(i);
System.out.println("课程:" + cr.id + ":" + cr.name);
}
}
/**
* 通过迭代器遍历List
*/
public void testIterator(){
Iterator it = coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问):");
while (it.hasNext()) {
Course cr = (Course)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);
}
}
/**
* 课程修改
* @param args
*/
public void testModify() {
coursesToSelect.set(4, new Course("7","毛概"));
testForEach();
}
/**
* 课程删除
* @param args
*/
public void testRemove() {
Course cr = (Course)coursesToSelect.get(4);
System.out.println("我是课程:" + cr.id + ":" + cr.name + " 我即将被删除");
coursesToSelect.remove(cr);//也可以把cr换成索引位置4,不过要考虑越界问题。
System.out.println("成功删除");
testForEach();
}
public void testRemoveAll() {
System.out.println("即将删除4和5位置上的课程");
Course[] courses = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));
System.out.println("成功删除");
testForEach();
}
public static void main(String[] args) {
ListTest lt = new ListTest();
lt.Add();
lt.testGet();
lt.testIterator();
lt.testForEach();
lt.testModify();
lt.testRemove();
}
}
SetTest
package testCollection;
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>();
}
/**
* 往List中添加元素
* */
public void Add() {
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 temp1 =(Course)(coursesToSelect.get(0));
//System.out.println("添加了课程:" + temp1.id + ":" + temp1.name);
//以下会产生数组越界异常
//Course cr3 = new Course("3","C++");
//coursesToSelect.add(3, cr3);
Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 =(Course)coursesToSelect.get(2);
//System.out.println("添加了课程:" + temp3.id + ":" + temp3.name);
Course temp4 =(Course)coursesToSelect.get(3);
//System.out.println("添加了课程:" + temp4.id + ":" + temp4.name);
Course[] course1 = {new Course("5","机器学习"),new Course("6","计算机网络")};
coursesToSelect.addAll(2,Arrays.asList(course1));
Course temp5 =(Course)coursesToSelect.get(2);
//System.out.println("添加了课程:" + temp5.id + ":" + temp5.name);
Course temp6 =(Course)coursesToSelect.get(3);
//System.out.println("添加了课程:" + 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);
}
}
/**
* 测试List的contains方法
*/
public void testListContains() {
Course course = coursesToSelect.get(0);
System.out.println("取得课程:" + course.name);
System.out.println("备选课程中是否包含课程:" + course.name + "," + coursesToSelect.contains(course));
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st = new SetTest();
st.Add();
st.testForEach();
Student stu = new Student("1","小明");
System.out.println("欢迎学生: " + stu.name + "来选课");
Scanner sc = new Scanner(System.in);
for (int i=0;i<3;i++) {
System.out.println("请输入课程ID:");
String courseId = sc.next();
for (Course cr:st.coursesToSelect) {
if (cr.id.equals(courseId)) {
stu.courses.add(cr);
}
}
}
for (Course cr:st.coursesToSelect) {
System.out.println("学生已选课程:" + cr.id + ":" + cr.name);
}
}
}
MapTest
package testCollection;
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
* @param args
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加:输入学生ID,判断是否被占用,
* 若没有则输入学生姓名,创建新的学生对象,添加到students属性中去
* @param args
*/
public void testPut() {
Scanner sc = new Scanner(System.in);
int i = 0;
while (i < 3) {
System.out.println("请输入学生ID:");
String ID = sc.next();
Student st = students.get(ID);
if (st == null) {
System.out.println("请输入学生姓名:");
String name = sc.next();
Student newStudent = new Student(ID,name);
students.put(ID,newStudent);
System.out.println("成功添加学生: " + students.get(ID).name);
i++;
}else {
System.out.println("该ID已被占用");
continue;
}
}
}
/**
* 测试MAp的keyset方法
* @param args
*/
public void testKeySet() {
//通过keySet方法返回Map中的key的集合
Set<String> keySet = students.keySet();
//取得students的容量
System.out.println("总共有" + students.size() + "个学生");
//遍历keySet,取得每一个key,在调用get方法,取得每一个键的value
for (String stuID:keySet) {
Student st = students.get(stuID);
if (st != null) {
System.out.println("学生:" + st.name);
}
}
}
/**
* 测试删除
* @param args
*/
public void testRemove() {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入要删除的学生ID:");
String ID = sc.next();
Student st = students.get(ID);
if (st == null) {
System.out.println("该ID不存在");
continue;
}
students.remove(ID);
System.out.println("成功删除学生:" + st.name);
break;
}
}
/**
* 通过entrySet返回所有键值对的集合
* @param args
*/
public void testEntrySet() {
Set<Entry<String, Student>> entrySet = students.entrySet();
for (Entry<String, Student> entry:entrySet) {
System.out.println("取得键:" + entry.getKey());
System.out.println("对应值为:" + entry.getValue().name);
}
}
/**
* 测试修改
* @param args
*/
public void testModify() {
System.out.println("请输入要修改的学生ID:");
Scanner sc = new Scanner(System.in);
while (true) {
String Id = sc.next();
Student st = students.get(Id);
if (st == null) {
System.out.println("该ID不存在,请重新输入");
continue;
}
System.out.println("该学生当前姓名为:" + st.name);
System.out.println("请输入新的学生姓名");
String name = sc.next();
Student newStudent = new Student(Id, name);
students.put(Id, newStudent);
System.out.println("修改成功");
break;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
MapTest mt = new MapTest();
mt.testPut();
mt.testKeySet();
mt.testModify();
mt.testEntrySet();
mt.testRemove();
mt.testEntrySet();
}
}
CollectionTest
package testCollection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class CollectionsTest {
/**
* 对Integer类型的泛型进行排序
* @param args
*/
public void testSort1() {
List<Integer> intList = new ArrayList<Integer>();
Random random = new Random();
Integer k;
for (int i=0;i<10;i++) {
do {
k=random.nextInt(100);
}while(intList.contains(k));
intList.add(k);
System.out.println("成功添加整数:" + k);
}
System.out.println("--------排序前----------");
for (Integer integer:intList) {
System.out.println("元素:" + integer);
}
Collections.sort(intList);
System.out.println("---------排序后------------");
for (Integer integer:intList) {
System.out.println("元素:" + integer);
}
}
/**
* 对String类型排序
* @param args
*/
public void testSort2() {
List<String> strList = new ArrayList<String>();
strList.add("Microsoft");
strList.add("Iphone");
strList.add("Lenovo");
System.out.println("--------排序前----------");
for (String string:strList) {
System.out.println("元素:" + string);
}
Collections.sort(strList);
System.out.println("---------排序后------------");
for (String string:strList) {
System.out.println("元素:" + string);
}
}
/**
* 对Student类排序
* @param args
*/
public void testSort3() {
List<Student> stuList = new ArrayList<Student>();
Random random = new Random();
stuList.add(new Student(random.nextInt(1000)+"","xiaoming"));
stuList.add(new Student(random.nextInt(1000)+"","xiaohong"));
stuList.add(new Student(random.nextInt(1000)+"","xiaoqiang"));
System.out.println("--------排序前----------");
for (Student stu:stuList) {
System.out.println("学号:" + stu.id + " " + "姓名:" + stu.name);
}
Collections.sort(stuList);
System.out.println("--------排序后----------");
for (Student stu:stuList) {
System.out.println("学号:" + stu.id + " " + "姓名:" + stu.name);
}
Collections.sort(stuList, new StudentComparator());
System.out.println("按照姓名排序后:");
for (Student stu:stuList) {
System.out.println("学号:" + stu.id + " " + "姓名:" + stu.name);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
CollectionsTest ct = new CollectionsTest();
//ct.testSort1();
//ct.testSort2();
ct.testSort3();
}
}
JDBCTest
package test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class testJDBC {
public static void main(String[] args) {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
System.out.println("成功加载JDBC驱动!");
}catch(ClassNotFoundException e){
System.out.println("没有找到JDBC驱动");
e.printStackTrace();
}
String sql = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useSSL=false";
Connection con;
try {
con = (Connection)DriverManager.getConnection(sql, "root", "123456");
Statement st = con.createStatement();
System.out.println("成功连接到数据库!");
ResultSet rs = st.executeQuery("select * from user");
System.out.println(rs.toString());
while (rs.next()) {
System.out.println(rs.getString("name"));
}
st.close();
con.close();
}catch(SQLException e) {
System.out.println("连接数据库失败!");
e.printStackTrace();
}
}
}
ServletTest
package servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class NewServlet
*/
@WebServlet(name = "NewServlet", urlPatterns = { "/my" })
public class NewServlet extends HttpServlet {
private transient ServletConfig servletConfig;
public void init(ServletConfig servletConfig) throws ServletException {
this.servletConfig = servletConfig;
}
public ServletConfig getServletConfig() {
return servletConfig;
}
public String getServletInfo() {
return "My Servlet";
}
public void service(ServletRequest request,ServletResponse response) throws ServletException,IOException{
String servletName = servletConfig.getServletName();
response.setContentType("text/html");
PrintWriter writer = response.getWriter();
writer.print("<html> <head> </head>" + "<body> Hello from " + servletName + "</body></html>");
}
public void destroy() {
System.out.println("销毁了");
}
}