学习笔记-Java8基础入门

一、Java基础入门

1.Java开发版本介绍

• Java官网：
  https://www.oracle.com
• 开发版本
  • JavaSE：Java Standard Edition（Java标准版），SE是开发JavaEE项目的基础，是开发桌面APP系统的基础。
  • JDK：Java develop kit（Java开发包）。
  • JRE：Java runtime environment（Java开发环境），是开发所有软件的基础包。
  • JavaEE：Java enterprise Edition （Java企业版），B/S开发模式，即B（浏览器，broswer）S（web server，APP server）。
  • JavaME：嵌入式开发（被安卓替代）。
• SpringBoot
  Maven:解决团队开发时，第三方包的下载、软件编译、部署等问题。
  SpringBoot：解决资源包版本冲突和相互依赖问题，简化开发，SpringBoot需要Java8的引用。

2.Java开发IDE选择

• IDE：集成开发环境
• 主要Java IDE
  JBuilder
  MyEclipse：收费
  Eclipse：开源免费
  IntelliJ idea
  Eclipse+STS
  Netbeans：sun官方推荐

3.Hello world示例

*.jar：java类的压缩包
*.class：java源码编译后的文件
*.java：源代码

4.工作区workspace的概念

Workspace：Java平台作为项目管理的文件区间
误区：1.把所有项目代码都放在一个project中，这样代码不容易管理，当开发人员多时，无法拆分项目。 2.不要把不相关的project放在同一个workspace。

5.project与package的概念

• Maven project：资源管理、打包、编译
• Dynamic：JavaEE项目
• EJB：Enterprise java bean
• JRE：是所有项目的基础
  JRE与JDK区别：JDK包含JRE，JDK=JRE+其他工具
• package
  • package的作用：解决命名冲突问题（变量命名，方法名）namespace
  • package命名规范：
    com.icss.bk.thread.biz
    cn.icss.bk.thread.biz
    范围.公司名简称.项目名简称.业务模块.层
    包名全部小写 用.进行分割
    

6.Java核心机制

• Java虚拟机（JVM）：跨平台
  垃圾收集机制：系统自动执行，不能强制执行

• .java：源代码文件
  bin文件夹：.java的文件编译后的结果放置在bin中
  *.class：半编译代码（字节码）
  .c–>>.exe 编译后的内容是二进制（机器码）----依赖于你的操作系统和CPU指令集
  

• Java编译器：针对Java虚拟机产生class文件，因此独立于平台
  Java解释器：负责将Java虚拟机的代码在特定的平台上运行

• Java程序和JavaScript都是解释运行的语言
  c程序是编译运行程序，运行速度更块，但容易内存泄漏

7.程序的主函数

• 一个程序一定要有一个启动点，从启动点开发分配内存
  Web project：web服务器启动时，加载项目（没有main函数）
  Java project：main函数

public static void main(String[] args) {
		
}

public：作用范围，在main函数中，只能使用public，不能使用private/protected/默认
void：表示这个函数无需返回任何信息
String[] ：表示字符型数组
args：参数的名字，可以修改
static：关键字，静态的 。静态变量、静态方法（表示这个方法与所在的class无关）

8.基本数据类型和引用类型

• 数据类型
  • 基本类型
    内存分配空间固定的数据类型
    byte 1字节
    1byte=8bit
    1bit：只一个0或一个1
  • 引用类型
    复杂的数据类型
    对象类型
    指针：指向某一块内存地址
    引用：间接指向内存地址
• 数值型
  • 整型
    byte：8位 1byte 范围：-2⁷~2⁷-1
    short：16位 2byte 范围：-2¹⁵~2¹⁵-1
    int：32位 4byte 范围：-2³¹~2³¹-1
    long：64位 8byte 范围：-2^63 ^~263^-1
  • 浮点型
    float：32位 4byte 范围：-3.403E38-3.403E38 例：12.5f
    double：64位 8byte 范围：-1.798E308~1.798E308 例：344.223D
  • 字符型
    char：16位 2byte 表示一个字符 例：‘安’ ‘a’
  • 布尔型
    boolean：8位 1byte 只有两个值true和false
• 引用数据类型
  类（class）–String：例：’biubiubiu哈哈’
  接口（interface）
  数组

9.Java中的运算符

算术运算符：+，-，，/，%，++，–
关系运算符：>，<，>=，<=，==，!=
布尔运算符：!，&&，||
赋值运算符：=，+=，-=，=，/=
字符串连接运算符：+
位运算符：&，|，~，^，<<，>>
条件运算符：表达式1?表达式2:表达式3

10.for循环

• 变量：
  局部变量：定义在方法内 ，作用域：这个变量所在的大括号
  成员变量
  静态变量

int sum=0;
for(int i=0;i<=100;i++) {
	sum+=i;
}

11.while循环

int k=0,sum2=0;
while(k<100) {
	k++;
	sum2+=k;
}

12.函数入门

• 函数（方法、行为）：
  void 返回值为空
  注意：函数命名，要用动词开头，首字母要小写

public int qiuhe(int m,int n) {
	int sum=0;
	for(int i=m;i<=n;i++) {
		sum+=i;
	}
	return sum;
}
	
public void qiuhe2() {
	int k=0,sum2=0;
	while(k<100) {
		k++;
		sum2+=k;
	}
	System.out.println(sum2);
}
	
public static void main(String[] args) {
	Test01 t=new Test01();
	int a=t.qiuhe(3,100);
	t.qiuhe2();
}

13.函数的形参与实参

public int qiuhe(int m,int n) {
}

m和n是两个int类型变量，都被称为形参
时间调用时，传入的具体数值，被称为实参

14.continue跳出本次循环

for(int i=m;i<=n;i++) {
	if(i%5==0) {
		continue;
	}
	sum+=i;
}

15.break跳出循环体

for(int i=m;i<=n;i++) {
	if(i%5==0) {
		break;
	}
	sum+=i;
}

16.基本类型的数组

• 断点调试：
  F6单步调试
  F8调到下一个断点

		int []shuzuA= {1,2,3,4}; //shuzuA.length       获取数组的长度
		int[] shuzuB=new int[10];

17.类和对象

• 类：类型，名词
• 抽象：从一群特殊的个体，提取他们共有的特征
  从特殊到一般的过程
• 对象：是一个特殊个体，这个个体有类的特性
  从一般到特殊的过程
• 类的抽取过程：
  1.提取名词
  2.提取属性信息
  3.提取行为信息
• biz：业务逻辑的缩写
  Ctrl+shift+o 快速导包

public class Dog {
	
	public String name;
	public String color;
	public double age;

}
public class TestDog {
	public static void main(String[] args) {
		Dog d1=new Dog();
		d1.name="憨憨";
		d1.color="黑色";
		d1.age=1.5;
		
		Dog d2=new Dog();
		d1.name="哈哈";
		d1.color="白色";
		d1.age=2.5;
		
		System.out.println(d1.name+d1.color+d1.age);
		System.out.println(d2.name+d2.color+d2.age);
	}

}

18.引用类型的数组

public static void testDogS() {
		
	Dog d1=new Dog();
	d1.name="憨憨";
	d1.color="黑色";
	d1.age=1.5;
		
	Dog d2=new Dog();
	d1.name="哈哈";
	d1.color="白色";
	d1.age=2.5;
		
	Dog d3=new Dog();
	d1.name="大黄";
	d1.color="黄色";
	d1.age=2.2;
		
	Dog[] dogs=new Dog[10];
	dogs[0]=d1;
	dogs[1]=d2;
	dogs[2]=d3;
		
	for(int i=0;i<dogs.length;i++) {
		Dog gg=dogs[i];
		if(gg!=null) {
			System.out.println(gg.name+gg.color+gg.age);
		}
	}
}
	
public static void main(String[] args) {
	TestDog.testDogS();
}

二、对象与封装

1.构造函数

• 默认构造函数
  特点：
  1.构造函数的名字与类名必须一致
  2.构造函数不能有返回值
  3.无参构造函数，为默认方法
• overload（重载）：一个类中有多个方法，同名不同参
• 在同样一块作用域内局部变量优先于成员变量

public class Dog {
	
	public String name;
	public String color;
	public double age;
	public int health;
	
//	public Dog() {  //默认构造函数
//		age=2.5;    //设置默认值
//	}
	
	public Dog(String name) {
		this.name=name;      //this 指当前对象
	}
	
	public void swim() {
		System.out.println(name+"is swimming");
	}
	
	public void playBall() {
		System.out.println(name+"is playing ball");
	}

}
public class GameUi {
	public static void main(String[] args) {
		Dog d1=new Dog("憨憨");
		Dog d2=new Dog("哈哈");
		
		d1.color="黄色";
		d2.color="黑色";
		
		d1.swim();
		d2.playBall();
	}

}

2.封装

• OOP：object orient program 三个重要特征：继承、封装、多态
• 封装：主要是为了代码安全
• entity:实体，只有属性，没有方法
  —POJO（简单Java类plain old java object）
  —VO（value object）
  —DTO（data transfer object）
  主要作用：跨层进行数据传输

public int getHealth() {
	return health;
}
public void setHealth(int health) {
	this.health = health;	
}

3.常量

public static final String MALE="male";
public static final String FEMALE="female";

三、继承

1.继承

• 关键词：extends
• 重写（override）：子类有和父类同名同参同返回值的方法，子类的方法会替掉父类的方法。子类可以继承父类protected和public的属性及方法。

super(name);         //由子类的构造函数向父类传参，此语句必须在第一行

2.重写与父类子类区别

• is-a:子是夫，如：Dog is a pet
  has-a

• 有些父类成员不能继承：
  –private成员
  –子类与父类不在同包，使用默认访问权限的成员
  –构造方法

3.多种封装关键字对比

• 封装的关键字：对比分析角度（类内、类外–对象、子类、宝内、包外）
  • private:私有属性、私有方法特点：只能在本类的内部调用
  • public:所有范围都可以调用
  • protected:子类（包内+包外）
    可以调用父类的protected属性方法
    包外外部对象无法调用protected属性方法
    包内外部对象可以调用protected属性方法
• 默认关键字：
  包内对象可用调用（子类+对象）
  包外（子类+对象）无法调用父类的默认关键字修饰的属性和方法
• 目的：代码安全

4.抽象类与抽象方法

• 抽象类：
  • 特点：
    1.类内既可以有抽象方法，也可以有非抽象方法
    2.抽象类的子类也可以是抽象类

public abstract class Pet {}

• 抽象方法：
  • 好处：强制子类必须实现父类的抽象方法（除非子类自身也是抽象类）
  • 特点：1.必须写在抽象类里面。2.抽象方法不能有实现体。

public abstract void play(); //给面向接口编程做准备

5.final关键字

• 什么时候使用
  1.类不希望再被其他类继承
  2.方法不希望被重写
  3.属性值不希望被修改

6.static关键字

1. 常量

public static final String FEMALE="雌性";
public static final double PAI=3.1415926;

2. 静态变量
   又叫类变量，区别于对象变量
   静态变量的生命期：一旦赋值，就永远不会释放（除非程序崩溃）
   局部变量：代码运行超过该变量所在的大括号范围，就被GC标记为垃圾，等待垃圾回收
   成员变量：代码运行超过该变量所属对象所在的大括号范围，所属对象就被GC标记为垃圾，等待垃圾回收，成员变量随所属对象一起消失

public static User user=null;

3. 静态方法
   类方法，不是对象方法
   特点：静态方法中不能调用成员变量，非静态方法可以调用静态变量

System.out.println(Dbconfig.getDriverClassName());

Integer.parseInt("101");
String.format("￥ %(,.2f", money);

4. 静态代码块

Static{
}

特点：1.当调用静态代码块所在类的方法和属性时，静态代码块会被最先执行（优先于构造函数）。2.静态代码块只能被调用一次

四、日期操作

1.日期的录入与输出

• java.util —Class Date
  在软件三层架构（在ui层和逻辑层应该使用java.util.Data，在持久层需要使用java.sql.Data）
  java.util.Data既包含日期，又包含时间
• java.sql —Class Date
  只有在持久层才能使用java.sql.Data，在其他层不能出现java.sql包下的内容
  java.sql.Data只进行日期的操作
• java.sql —Class Timestamp
  java.sql.Timestamp进行时间+日期的操作
• java.util —Class Calendar
• java.text—Class SimpleDateFormat

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {
	
	public static void outUtilDate() {  //获取当前的默认时间
		
		Date date=new Date();     //获取当前的默认时间-----年月日小时分秒
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");
		String aa=sd.format(date);
		
		System.out.println(date); //默认为date.toString()
		System.out.println(aa);
	}
	
	public static void inputUtilDate() {  //日期录入（文本转换日期对象）
		String aa="2015-03-17";   
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date d=sd.parse(aa);
			System.out.println(d.toString());
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public static void main(String[] args) {
		outUtilDate();
		inputUtilDate();
	}

}

2.java.sql.Date与java.util.date之间的转换

• 如何把java.util.Date转换成java.sql.Date

pst.setDate(1, new java.sql.Date(birthday.getTime()));

• 如何把java.sql.Date转换成java.util.Date

java.util.Date birthday2=new java.sql.Date(1224);

注意：子转父是安全的，因为不会出现内存越界

• public long getTime()
  返回自1970年1月1日以来，由 Date对象表示的00:00:00 GMT的毫秒 数 。
  结果 ：自1970年1月1日以来，以此日期为准的00:00:00 GMT的毫秒数。

• public Date(long date)
  使用给定的毫秒时间值构造一个Date对象。 如果给定的毫秒值包含时间信息，则驱动程序将将时间组件设置为对应于零GMT的默认时区（运行应用程序的Java虚拟机的时区）。
  参数 ：date - 1970年1月1日以来的毫秒，GMT 00:00:00不超过8099的毫秒表示。负数表示1970年1月1日00:00:00 GMT之前的毫秒数。

	public static void inputSqlDate() {

		try {		
		    SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");
		    java.util.Date birthday=sd.parse("1998-11-24");
		    
			Connection conn=null;
		    String sql="insert into tuser values(?,?,?,?)";
		    PreparedStatement pst= conn.prepareStatement(sql);
		    pst.setDate(1, new java.sql.Date(birthday.getTime()));  
		    pst.execute();
		    
		    //java.util.Date birthday2=new java.sql.Date(1224);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

3.java.sql.TimStamp与java.util.date之间的转换

	public static void inputSqlTimstamp() {

		try {		
		    SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		    java.util.Date optime=sd.parse("1998-11-24 12:24:07");
		    
			Connection conn=null;
		    String sql="insert into tuser values(?,?,?,?)";
		    PreparedStatement pst= conn.prepareStatement(sql);
		    pst.setTimestamp(1, new java.sql.Timestamp(optime.getTime()));  
		    pst.execute();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

4.使用Calendar进行日期运算

	public static void testCalendar() {
		Calendar cal=Calendar.getInstance();
		cal.setTime(new Date());              //日历对象
		cal.add(Calendar.DAY_OF_MONTH,5);
		
		int year=cal.get(Calendar.YEAR);
		int month=cal.get(Calendar.MONTH);
		int day=cal.get(Calendar.DAY_OF_MONTH);
		
		System.out.println(year+"年"+month+"月"+day+"日");
	}

5.LocalDate日期输出

• java.time—Class LocalDate
  LocalDate是一个不可变的年月日对象

	public static void outUtilDate() {
		LocalDate date=LocalDate.now();
		DateTimeFormatter df=DateTimeFormatter.ofPattern("MM/dd/yyyy");
		String aa=date.format(df);
		System.out.println(aa);
	}

6.LocalDate日期录入

	public static void inputUtilDate() {
		String date="2018-10-01";
		LocalDate aa=LocalDate.parse(date);//按默认ISODate格式
		System.out.println(aa.toString());
		
		String date2="07/23/2017";
		DateTimeFormatter df=DateTimeFormatter.ofPattern("MM/dd/yyyy");
		LocalDate bb=LocalDate.parse(date2,df);
		System.out.println(bb.toString());
	}

7.LocalDate日期调整

	public static void testCalendar() {
		LocalDate date=LocalDate.of(2017, 10, 8);
		date=date.plusDays(10);
		date=date.plusMonths(3);
		
		int year=date.getYear();
		int month=date.getMonthValue();
		int day=date.getDayOfMonth();
		
		System.out.println(year+"年"+month+"月"+day+"日");
	}

8.java.sql.Date与LocalDate之间的转换

• 在java8中jdbc的接口没有发生变化
  Interface PreparedStatement
  void setDate(int parameterIndex,Date x)
  throws SQLException使用运行应用程序的虚拟机的默认时区将指定的java.sql.Date设置为给定的java.sql.Date值。 当驱动程序将其发送到数据库时，将其转换为SQL DATE值
  void setTimestamp(int parameterIndex, Timestamp x)
  将指定的参数设置为给定的 java.sql.Timestamp值。

• 在java8的java.sql.Date中新增了如下方法：
  static Date valueOf(LocalDate date)
  从一个LocalDate对象获取一个Date的实例，具有与给定的LocalDate相同的年，月和日的月值。

• 注意：为什么jdbc的接口仍然使用java.sql.Date和java.sql.TimeStamp?
  为什么不把jdbc接口改成java.time.LocalDate和java.time.LoaclDateTime ?
  java和javaEE主要是提供编程规范的，实现是由各个厂商来做的

• 如何把LocalDate转为java.sqlDate

	public static void inputSqlDate() {

		try {		
		    LocalDate date=LocalDate.of(2016, 5, 8);
		    
			Connection conn=null;
		    String sql="insert into tuser values(?,?,?,?)";
		    PreparedStatement pst= conn.prepareStatement(sql);
		    java.sql.Date bb=java.sql.Date.valueOf(date);  //转换
		    pst.setDate(1, bb);  
		    pst.execute();
		    
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

• 如何把java.sqlDate转为LocalDate

	public static void outputSqlDate() {
		java.sql.Date date=new java.sql.Date(1224);
		LocalDate aa=date.toLocalDate();
		System.out.println(aa.toString());
	}

9.java.sql.TimStamp与LocalDateTime转换

• LocalDateTime转为java.sql.TimStamp

	public static void inputSqlTimstamp() {
		try {		
		    LocalDateTime time=LocalDateTime.of(2016, 5, 8,13,25);
		    
			Connection conn=null;
		    String sql="insert into tuser values(?,?,?,?)";
		    PreparedStatement pst= conn.prepareStatement(sql);
		    java.sql.Timestamp bb=java.sql.Timestamp.valueOf(time);  //转换
		    pst.setTimestamp(1, bb);  
		    pst.execute();
		    
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

• java.sql.TimStamp转为LocalDateTime

	public static void outputSqlTimstamp() {
		java.sql.Timestamp bb=new java.sql.Timestamp(1224);
		LocalDateTime time=bb.toLocalDateTime();
	}