java是完全面向对象的编程语言
1.什么是Object？：Object：东西，是指具体事务的实例
面向对象：就是面向客观事物之间的联系
----------------------------------------------------------------------------------------------
1.类和对象
类：一类事物，抽象的概念
对象：一个事物，具体的概念
封装：任何对象实例都尽可能的封装；
多态：事务在不同的情况下有不同的变化；
继承：概念继承关系（我继承了我父亲所有的优点）；
类与对象的联系和区别：
类代表的是一类事务，他是对象的模板
对象：代表的是一个事务的实例，是类的一个实现
-------------------------------------------------------------------------------------------------
2.描述人这个类：动态信息1、说话2、计算的行为
静态信息：1.姓名2.年龄3.银行存款
属性和方法
--------------------------------------------------------------------------------------------------
3.java当中如何去描述一个类？
class 类名{
属性（变量）；
方法：
}
案例：Object1.Demo/Person
class Person（）{
属性：姓名，年龄，性别，身高，体重
}
-----------------------------------------------------------------------------------------------
4.创建对象
1）.创建对象的格式：
a.对象的声明
类名 对象名
b.对象的创建 类名 对象名=new 构造方法();
2）.访问对象中的属性/方法
a.访问属性：对象名 .属性名
b.访问方法：对象名.方法名
java中变量：8种基本类型和引用类型（基本类型之外全是引用类型的）；
3）.对象属性的默认值：
对象当new完以后在堆当中
创建存储空间里，jdk会自动把数据类型的变为0，引用类型的变为null；
-----------------------------------------------------------------------------------------------
5、引用类型变量以及对象在内存中创建的过程
1）、java内存管理与分配，
栈：先进后出，存储局部变量 一块使用的内存区域
堆：java中 一块使用的内存区域 使用方式：随机的分配
new 的对象
2）、变量的类型
变量分为两个类型：基本类型和引用类型
基本类型：占用的空间，就是基本数据类型占用的空间
值就是基本数据类型的值
引用类型：应用类型的值就是在堆当中new生成的对象的地址值，
可以通过引用类型中的地址值找到在堆当中的对象，
----------------------------------------------------------------------------------------------------
6.案例：
长方体类：box，
属性：长，宽，高
方法：求体积（长，宽，高）
根据BOX来创建一个BOX对象，并求体积
------------------------------------------------------------------------------------------------------
7.构造方法
1）.构造方法作用：用来描述对象的创建过程，（就是用来创建对象给属性赋初值，或者做其他的初始化操作）
2）.java中的构造方法：在我们的类当中声明，方法名跟类名一致，而且构造方法没有任何的返回值，没有返回值类型，
当创建对象的时候就会立刻调用构造方法，类给对象初始化，
3）.对象的实例化过程
new：在我们的堆当中创建我们的对象的过程
a.根据类的属性在堆当中分配存储对象的空间，并且先自动给这些属性赋默认值，
b.根据参数来调用构造方法（把默认值变成对象要赋的值）
c.new 返回的是对象的堆当中引用地址
4）.this关键字：
this：当前，只代当前对象（对当前对象的引用）
a).企业开发中：构造方法的参数的名字跟属性名最好一致
this.属性名//当前这个对象的属性
this.方法名//当前这个对象的方法
this(参数)：跟构造方法重载结合使用，可以调用本类中的其他的构造方法，必须要写到当前构造方法中的第一行
参数要跟调用的构造方法的参数匹配
5）.构造方法重载
一个类中有很多的构造方法，根据参数的不同，来选择调用不同的构造方法
案例：
/*
* 设计Car类，
* 属性：name，color,money,speed
* 方法：行驶
* 写两个构造方法，第1个构造方法，要把所有的属性都初始化了
* 第2构造方法，只把name/color
*/
* 设计Car类，
* 属性：name，color,money,speed
* 方法：行驶
* 写两个构造方法，第1个构造方法，要把所有的属性都初始化了
* 第2构造方法，只把name/color
*/
public class Car {
String name;
String color;
double money;
int speed;
public Car(double money,String name,String color,int speed){
this.name=name;
this.money=money;
this.color=color;
this.speed=speed;
}
public Car(String name,String color){
this.name=name;
this.color=color;
}
}
String name;
String color;
double money;
int speed;
public Car(double money,String name,String color,int speed){
this.name=name;
this.money=money;
this.color=color;
this.speed=speed;
}
public Car(String name,String color){
this.name=name;
this.color=color;
}
}
6）.默认的构造方法：
a).java类当中必须要有构造方法
b).当new的时候必然会调用构造方法
c).如果类当中没有写任何构造方法系统默认创建空参的构造方法
如果写了有参的构造方法，则系统会默认覆盖空参的构造方法
Box box=new Box();
box.Box@4f1d0d 包名.类名@哈希code//有地址了，对象创建成功
----------------------------------------------------------------------------------------------------
7.方法重载：
1.方法重载：是在同一个类里面，方法名相同，参数不同（参数类型不同，参数个数不同，参数顺序不同）返回值可以不相同
2.方法重载中通过参数不同，来调用/区分不同的方法
3.是一种多态的表现方式
--------------------------------------------------------------------------------------------------------------
8.参数
java中参数传递的一般规则：
基于值的传递，基本数据类型的变量的值复制到形参当中；
引用类型变量：把堆对象的地址的值，传递到形参当中（堆当中对象的首地址），这样实参和形参指向同一个地址值。
public class Demo{
public static void main(String[] args) {
Car car=new Car();
System.out.println(car.money);
show(car);
System.out.println(car.money);
}
public static double show(Car cr){
cr.money=90;
return cr.money;
}
}
class Car {
String name;
String color;
double money=12;
int speed;
public Car(){
}
public Car(double money,String name,String color,int speed){
this.name=name;
this.money=money;
this.color=color;
this.speed=speed;
}
public Car(String name,String color){
this.name=name;
this.color=color;
}
}
public static void main(String[] args) {
Car car=new Car();
System.out.println(car.money);
show(car);
System.out.println(car.money);
}
public static double show(Car cr){
cr.money=90;
return cr.money;
}
}
class Car {
String name;
String color;
double money=12;
int speed;
public Car(){
}
public Car(double money,String name,String color,int speed){
this.name=name;
this.money=money;
this.color=color;
this.speed=speed;
}
public Car(String name,String color){
this.name=name;
this.color=color;
}
}
-------------------------------------------------------------------------------------------------------------
9，继承:
一个子类可以继承父类的所有的属性和所有的方法
目的：代码重用
子类继承父类game
----------------------------------------------------------------------------------------------------------
10.继承中的构造方法，
在真实企业开发中一定要写一个空参的构造方法。
1）.子类的构造方法，一定要调用父类的构造方法
2）.子类不能继承构造方法
3）.如果父类中没有无参的构造方法，则必须在子类的构造方法中明确的调用父类中的有参数的构造方法。
4）.super():曾经的，过去的
super（）来调用父类的带参的构造方法。
父类中没有空参的构造方法的时候必须使用super，
而且super必须要放在子类构造方法的第一行
-----------------------------------------------------------------------------------------------------------
11.方法的重写（覆盖）/变量的隐藏都出现在继承当中
1）.变量隐藏：子类定义的变量和父类中变量的名字一样，
则父类中的变量会被子类中的变量给覆盖
2）.super.属性名：可以调用被覆盖的父类中的属性
3）.方法的重写（覆盖）：
子类定义的方法：方法名，参数和返回值类型跟父类中的方法一致了，
则父类的方法被子类的该方法给重写（覆盖了）
----------------------------------------------------------------------------------------------------
12.this和super
1）.this：当前的，现在的 this.属性 this.方法
super：曾经的，过去的 super.属性 super.方法
2）.this(参数)：调用本类中的其他的构造方法
super(参数)：调用父类中的构造方法
-----------------------------------------------------------------------------------------------------
13.父类声明指向子类对象
1).该对象可以访问子类重写父类的方法
2).不可以访问子类独有的方法
3).可以强制的转化为子类对象
java是先编译，foo1的对象是父类对象，指向是堆当中的子类对象
父类声明指向子类对象不可以调用子类独有的方法。
public class Demo{
public static void main(String[] args) {
Car car=new Smart();
car.Driver();//该对象可以访问子类重写父类的方法
//car.D();//不可以访问子类独有的方法
Smart s=(Smart) car;
s.D();//.可以强制的转化为子类对象
}
}
class Car {
String name;
String color;
double money=12;
int speed;
public Car(){
}
public Car(double money,String name,String color,int speed){
this.name=name;
this.money=money;
this.color=color;
this.speed=speed;
}
public void Driver(){
System.out.println("开始行驶");
}
}
class Smart extends Car{
String name="smart";
public Smart() {
super();
// TODO Auto-generated constructor stub
}
public Smart(double money, String name, String color, int speed) {
super(money, name, color, speed);
// TODO Auto-generated constructor stub
}
public void Driver(){
System.out.println("开始行驶2222");
}
public void D(){
System.out.println("-----------");
}
}
public static void main(String[] args) {
Car car=new Smart();
car.Driver();//该对象可以访问子类重写父类的方法
//car.D();//不可以访问子类独有的方法
Smart s=(Smart) car;
s.D();//.可以强制的转化为子类对象
}
}
class Car {
String name;
String color;
double money=12;
int speed;
public Car(){
}
public Car(double money,String name,String color,int speed){
this.name=name;
this.money=money;
this.color=color;
this.speed=speed;
}
public void Driver(){
System.out.println("开始行驶");
}
}
class Smart extends Car{
String name="smart";
public Smart() {
super();
// TODO Auto-generated constructor stub
}
public Smart(double money, String name, String color, int speed) {
super(money, name, color, speed);
// TODO Auto-generated constructor stub
}
public void Driver(){
System.out.println("开始行驶2222");
}
public void D(){
System.out.println("-----------");
}
}
案例：
Question：
属性：题号 题干 选项
方法：
1.打印：显示到我们的控制台上
2.判断对错：返回false让子类去重写判断对错的方法
单选题
SingleQuestion
方法：重写判断对错的方法（符合单选题的特点）
多选题
MultiQuestion
方法：
重写判断对错的方法（符合多选题的特点）
//"=="判断两个对象相等，判断的是基本数据类型的相等，
//equals：引用类型值的比较相等
//用一个数组来保存SingleQuestion 对象和MultiQuestion对象
//声明一个父类数组
Question[] question =new Question[2];
//给question数组添加元素：父类的声明指向子类的对象
question[0]=new SingleQuestion(1,"中国最后一个未尝败绩的将军是谁？"new String[]{"A.白起"，"B.赵云"，"C.朱棣"，"D.戚继光"}，new String[]{"D"});
question[2]=new MultiQuestion(2,"java的课程由哪几位老师教授？"new String[]{"A,liyi","B.qiange","C.canglao","D.wuhua"},new String[]{"A","B","C","D"});
根据我们输入的内容来判断我们输入的答案是否正确
Scanner scanner=new Scanner(System.in);
-----------------------------------------------------------------------------------------------------------------
13.static:静态
a）.static 修饰（关键字），可以用来修饰：变量，方法，语句块，类
b）.static修饰的变量：属于类级变量，是在类加载的时候直接加载到内存当中，所有的类的对象可以共享同一个静态变量
特点：用static 修饰变量，我们叫做静态变量，该变量跟类有关，跟对象无关、
静态变量的访问：类名.静态变量名
当第一次new的时候 就会在内存空间
c）.static修饰方法：属于类的方法，所有该类的对象都可以访问该方法
特点：用static 修饰方法，我们叫做静态方法，该方法跟类有关，跟对象无关、
静态方法的访问：类名.静态方法名
在静态方法里面不可以调用实例变量：但可以调用静态变量
d）.代码块：用{语句}的java的语句块，每次在创建对象的时候，自动调用
e）.静态代码块：使用static修饰的代码块，不管该类创建多少个对象，静态代码块只调用一次，在jdbc和hibernate，Spring中使用及其频繁。
----------------------------------------------------------------------------------------------------------------
14.访问权限控制
-------------------------------------------------------------------------------------------------------------------
15.javaBean（pojo）
不是语法，是企业开发为了开发方便，习惯性的编码规范
特点：1.类必须要放到一个包下面
2.属性定义为私有的，必须要有能够访问该属性的方法
3.给访问属性的方法，命名的规范，属性名：XXX，访问的方法的名字，必须：一般属性：
getXXX（） setXXX（参数）
boolean类型的属性： isXxx（） setXXX（参数）
4.该类必须要实现可序列化接口（IO再说）通过序列化进行标识，标识硬盘中的地址一万个人进行访问 要把内存访问到 硬盘中5.javaBean必须要有空参的构造方法
16.final 最终的，最后的
修饰的类，方法，属性
1.用final修饰的类，表示这个类不可以被继承，叫做最终类
jdk的工具类大部分都是用final修饰的。我们写的类大部分都不要用final修饰（final修饰的类不可再实现动态代理）
2.用final修饰的方法不可以在重写
3.final修饰的变量，该变量
初始化以后不可以在被修改
a.final修饰的局部变量b.用final修饰的方法参数c.用final修饰的引用类型的变量（这个对象不可以修改，但是对象的属性可以修改）d。常量：值永远都不改变，
---------------------------------------------------------------------------------------------------
17.抽象类
抽象类：
-------不是具体的类（有的方法没有实现）
1）.抽象的方法-----只有行为的概念，没有具体的实现
（只有方法的声明，没有方法的实现，需要靠子类来实现）
格式：public abstract 返回值类型 方法名字（参数列表）；
2）.含有抽象方法的类，叫做抽象类
格式：abstrct class 类名{
}
3）抽象类的子类必须实现所有的抽象方法
4）抽象类只能被继承，一个具体的类来继承一个抽象类，并且实现抽象的方法
5）抽象类不能直接实例化，但可以使用父类声明指向子类对象
案例：
图形类Shape：抽象类
属性：point（x，y）
方法：1）.求该图形的面积
2）判断一个点point是否在图行的上面
3）判断一个点（x,y）是否在图形上
园（circle）：具体类，继承图形类，并且要实现其方法
public class Demo{
public static void main(String[] args) {
Circle c = new Circle();
System.out.println(c.mianji());
System.out.println(c.isShapePoint1(2, 3));
}
}
class Piont{
int x;
int y;
Piont(int x,int y){
this.x=x;
this.y=y;
}
}
abstract class Shape{
Piont piont;
abstract double mianji();
abstract String isShapePoint1(int x,int y);
}
class Circle extends Shape{
double mianji=0;
//半径假设为10；
double R=2;
//圆心
Point point=new Point(1,1);
String isShapePoint1(int x,int y){
System.out.println(point.x);
return (Math.sqrt((x-point.x)*(x-point.x)+(y-point.y)*(y-point.y))<=R ? "yes" : "no");
}
@Override
double mianji() {
mianji=Math.PI*R*R;
return mianji;
}
}
---------------------------------------------------------------------------------------------------
18.接口（接口和接口可以实现多继承）
1）.接口一般认为是一个特殊的抽象类
2）.特点：接口中的方法全部都是抽象方法，接口中的属性全是常量
接口和抽象类的区别
abstract class 类名{
属性
构造方法
一般方法
抽象方法
}
interface 接口名{
常量
抽象方法
}
Serializable----标识硬盘中的地址，实现序列化的接口（标识性接口，没有方法实现）
3）.接口不能直接实例化，可以让实现类来实例化，接口跟实现类就是继承关系，，实现接口的子类：必须要实现接口中所有的方法
4）.接口可以使用上转型
5）.java中类的继承单继承，接口实现多实现
--------------------------------------------------------------------------------------------------------
19.Object
java体系中最底层的一个类，Object是所有类的父类，所有的类都间接或直接的继承Object
案例：
Object：toString();--->用来描述当前对象的文本（String）信息，一般是默认调用，返回的结构是 包名.类名
@hashCode
随机返回的机制是没用的，必须重写
把属性信息描述出来（要把该类的对象显示出来）
object:hashCode();
当前对象在堆当中一个地址，通过转换出来的一个值，没有实际用处
a.如果重写equals，必须同时重写hashCode()
如果两个对象相等，equals返回true，而且必须要有相等的hashCode
b.如果两个对象不相等，equals返回false，而且hashCode不等
必须要重写equlas
a.比较两个对象是否相等
“==”：比较的是引用值是否相等（堆当中的对象的地址是否相同）
“equals（）”：Object根上的类，equals比较就是“==”，但是
我们认为的相等，一般指的属性，所以equals跟比较有关的时候，必须重写
重写equlas的时候一定要重写hashcode
列：
public class Car{
String name;
String color;
public Car(String name, String color) {
super();
this.name = name;
this.color = color;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((color == null) ? 0 : color.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
//跟null比较，返回值false
if (obj == null)
return false;
//this:指代当前对象，obj是要比较对象的引用（this和obj都是对象）
//两个引用值相等（地址值一样），则表示都指向堆中的同一个对象
if (this==obj){
return true;
}
//对象之间要比较，首先是同一个类型的对象
//instanceof 判断对象是不是同一个类的对象
//是返回true，反之，false
if (obj instanceof Car){
Car car= (Car) obj;
return this.name==car.name&&this.color==car.color;
}
return false;
}
}
String name;
String color;
public Car(String name, String color) {
super();
this.name = name;
this.color = color;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((color == null) ? 0 : color.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
//跟null比较，返回值false
if (obj == null)
return false;
//this:指代当前对象，obj是要比较对象的引用（this和obj都是对象）
//两个引用值相等（地址值一样），则表示都指向堆中的同一个对象
if (this==obj){
return true;
}
//对象之间要比较，首先是同一个类型的对象
//instanceof 判断对象是不是同一个类的对象
//是返回true，反之，false
if (obj instanceof Car){
Car car= (Car) obj;
return this.name==car.name&&this.color==car.color;
}
return false;
}
}
------------------------------------------------------------------------------------------------------------
20.String（字符串）
1.String 底层就是char[]可以简化对字符的操作 封装一些常用的方法，，
String =char[] +方法
String重写了我们的tostring 和hashcode 和 equals
String str1="liu";
String str2="liu";
str1==str2//true
str1.equals(str2);//true
2.一旦初始化后，永远不能改变 String str="liu"; str="liu"+"a";
3.String中的字面量的转化问题
public static final String name="liu";//常量
-------------------------------------------------------------------------------------------------------
21。StringBuffer（可变字符串）和StringBuilder
不变了之后，对其修改都会返回一个新的的字符串，为了你拟补不足，都要依赖字符串
String =char[] +方法（执行返回是一个新的字符串）
StringBuffer=char[]+方法（直接对char[]进行操作）
append（任意的参数）
常用的方法
区别和联系：
动态分页
StringBuffer 出现较早，速度比较慢，线程安全
StringBuilder 出现较晚 ，速度快，不安全
对比StringBuffer和StringBuilder的效率
----------------------------------------------------------------------------------------------------------------
22、集合---
list---线性表，表示有先后次序的对相集合（接口），有很多个子类实现
ArrayList-一种集合，跟数组非常相似（数组的一类线性表）大小不用指定可以保存任何数据，
----可变长的数组，存储性能好
----可以保存任意的对象，不用指定元素数量
----ArrayList添加元素有先后顺序，会自动转换为Object，取出要强制类型转换
----方法
add（）---有先后顺序
size（）
set（index ,obj）
get（index）
----保存的元素是有先后次序的的集合
----跟数学中的集合：交集和并集
LinkedList
----是一个双向循环链表，内部的属性会帮你保存下一个元素的地址
----修改和删除元素非常方便，保存输出比较麻烦
----linkedList 和 ArrayList方法:相似：linkedList因为是链表，修改删除较为方便
getfrist()
addfrist（）
addLast()
getLast()
----链表结构，更加稳定，更加安全
----------------------------------------------------------------------------------
ArrayList--可变长的数组，便于存储和显示（替代数组）
linkedList--双向循环列表，便于修改和删除
----------------------------------------------------------------------------------
父类声明指向子类对象，
list a=new ArrayList();
list b=new LinedList();/有很多独有的方法，
-------------------------------------------------------------------------------------
set--无序，不重复的，
一个接口，hibernate----所以没有下标值
---hashSet
：
![]()
-----------------------------------------------------------
Map（接口）
---HashMap（实现类）
添加：put()
toString()
hashCode()
equals（）
如果key值一样，后面的value值覆盖前面的
key--value会一一对key不能重复，并且一个key只对应一个value
集合框架：保存数据（因为数据不够强大，大小有一个指定，类型叫单一）
集合：大小不定，保存类型会自动转换成为object
接口：别的公司 需要完善，所以多了许多接口
-----------------------------------------------------------------------------------------
List：现象表
set：不包含重复元素的无序集合，并且最多包含一个null。
泛型：
1.jdk1.5以后出现了，在java程序编译阶段，定义好这个对象的类型
2.类名<类型> 对象名=new 构造方法<类型>()
约束类中属性的类型（元素）
3.class 类名<leixing> {
类型 变量名；
}
自动装箱/自动拆箱
小项目：贪吃蛇：
collections工具类
--------------------------------------------------------------------------------------------------------------------------
java中的异常
1.)行为（方法/过程）出现意外的情况
2）.java中的异常，在方法调用的时候，出现问题，先抛出一个异常对象，终止程序
3）.try....catch
案例:exception1.Demo8
4)try{
可能出异常的代码
}catch(异常类1 e){
处理方案1
}catch(异常类2 e){
处理方案2
}...
}finally{
不管有没有异常,都必须要执行的代码
}
a try: 有可能出异常的代码
b catch(异常类 e):截获在try当中出现的异常对象,然后再
catch的代码中,合理的处理(打印异常的信息)
c finally: 不管有没有异常都必须执行的部分
5) catch中可以输出的异常的信息
e.printStackTrace():
打印异常的堆栈信息,对异常的信息非常详细,开发的经常使用
e.getMessage():
返回是一个字符串,显示异常的信息
案例: exception.Demo9
6) 异常的体系结构
Throwable 类是 Java 语言中所有错误和异常的超类
Error 是 Throwable 的子类，用于指示合理的应用程序
不应该试图捕获的严重问题。
(OutOfMemoryError因为内存溢出或没有可用的内存提供给垃圾回收器时，
Java 虚拟机无法分配一个对象，这时抛出该异常。 )
Exception 类及其子类是 Throwable 的一种形式，
它指出了合理的应用程序想要捕获的条件
RuntimeException 继承于Exception
是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类
Throwable(java中异常或错误的根类)
Error Exception(异常的根类)
一般性异常 RuntimeException
(必须要显示抛出或tryCatch) (运行期异常)
NullPointExcetpion
ArithmeticException
7) 所有的异常都必须要直接或者间接的继承Exception
8) catch捕获的异常的层次
try{
可能出异常的代码
} catch(异常类1 e){//小异常
} catch(异常类2 e){//大异常
}
案例:exception1.Demo10
1.自定义异常，继承Exception 定义的就是一般性异常
2.实现Exception中的构造方法（4个)
案例:
用户登录的情况:用户名和密码都正确,登录才能成功
用户名错了,可以抛出一个异常,表示因为用户名错误才登录失败的
密码）
------------------------------------------------------------------------------------------------------------------------------------
1 内部类
在一个类的内部还包含一个类
1)静态内部类:使用static修饰类,并且把该类声明在另外类
当中
格式:
class 类名{
static int num =22;
static class 类名{
使用num
}
}
特点:静态内部类只能访问外界的静态变量
2)成员内部类:声明在类当中,不用static修饰的类
格式:
class 类名1{
int num;
class 类名2{
void show(){
System.out.println(num);
}
}
}
特点:成员内部类可以访问外界的属性(实例变量)
案例: inner2.Demo1/Foo/Koo
3) 局部内部类:一个类写到了一个方法的内部,非常少用
格式:
方法{
class 类名{
}
}
eg :
public static void main(String[] args){
final int num = 12;
class Koo1{
void show(){
System.out.println(num);
}
}
}
特点: 局部内部类如果使用外界的变量的时候,该变量必须使用
final修饰
案例 :inner2.Demo2/Koo1
4)匿名内部类:使用及其广泛,而且可以写到代码中的任何的位置
格式:
类名 对象名 = new 类名(构造方法){
方法
};
强调:使用匿名内部类的时候,一定不能含有带参数的构造方法,企业开发中
千万别写构造方法
案例:inner2.Demo3
2 java中的时间
Java中的时间就是1970 00:00:00到现在的毫秒数
1)为了开发方便Java用"很好"的一个类(Date)来对时间进行
处理
2) 时间的本质: Date = long + 方法
3) Date中常用的方法
a //date.getYear():该方法,sun不推荐使用(我们必须用),容易出现误差
//2000以后的,必须加上1900这个偏移量
int year = date.getYear()+1900;
b //date.getMonth():该方法,要加1
int month = date.getMonth()+1;
c Date now = new Date();
now:默认表示当前的时间
案例: date1.Demo5
4) 日期的输入和输出
日期的输入:把在页面部分输入的时间,传递给后台
(String) (Date)
日期的输出:把后台的时间传递前台(页面)
(Date) (String)
案例: date1.Demo6
// 格式: yyyy-MM-dd
SimpleDateFormat sdf =
new SimpleDateFormat("yyyy-MM-dd");
//SimpleDateFormat(格式):Date的格式的工具类,根据格式
//String <-----> Date 任意转换
//String ------> Date
//输入:把前台传递过来的String(时间)转化为对应的Date(时间)
Date date = sdf.parse("2000-10-10");
System.out.println(date);
//Date -------> String
//输出:把后台date(时间)转化为String(时间)显示到前台(页面)
Date date2 = new Date();
String date22 = sdf.format(date2);
System.out.println(date22);
5) java另外处理时间的工具类 Calendar
public abstract class Calendar{
}
a 创建Calendar
Calendar calendar = new GregorianCalendar()
默认是当前的时间
Calendar calendar = new GregorianCalendar(年,月,日)
b 显示时间
当前的年份: 对象名.get(Calendar.Year)
当前的月份: 对象名.get(Calendar.Month)
6)
Date date = new Date(long);
Date date = new Date(0);---> 1970年
时间
Timer 和TimerTask（抽象类）
run（）方法
schedule（TimerTask task，long delay，long period）;
Date和DateFormat
计算机表达的时间是毫秒，毫秒数
long表示的
Date封装了long 时间毫秒数
Date =long 时间数据+算法（历法）方法
SimpleDateFormat
6.java多线程编程
数据比代码重要
1.指令+数据的byte序列，如：qq.exe
2.正在运行的程序：进程
635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
