JAVA面向对象（OOP）-class 类
一、Object-Oriented-Programming面向对象编程
-
- 1.构造器
- 2.封装（高内聚，低耦合）
- 3.继承，方法重写，多态 instanceof关键字和类型转换（父类与子类的转换）
- 4.static关键字
- 5.抽象类（abstract) 约束。
- 6.接口
- 7.内部类
- 8.Exception(异常）
- 9.包装类(基本类型的引用类）
- 10.整数缓冲区
- 11.String
- 12.StringBuffer可变长字符串jdk1.0就提供了，运行效率相对StringBuilder慢，线程安全(StringBuilder jdk1.5提供，运行效率快，线程不安全）
- 13.bigDecimal
- 14.Date类、Calendar类、SimpleDateFormat类 System类
1.构造器
1.构造器：用来初始化值 是默认的无参构造；
2. 使用有参构造的时候必须显示的定义无参构造
3. 使用new 关键字，本质是在调用构造器
package com.f.www.object.oopDemo01;
public class Person {
//一个类即使什么都不写，它也会存在一个方法-默认的无参构造
//显示的定义构造器
String name="qinjiang";
int age;
private int money=10_0000_0000;
//实例化初始值
//使用new 关键字，本质是在调用构造器
//用来初始化值
public int getMoney(){
return money;
}
public void setMoney(int money){
this.money=money;
}
public Person(){
};
//this.name="qinjiang";
public Person (String name){
this.name=name;
}
public void print(){
System.out.println(name);
}
public void say(){
System.out.println("hi");
}
//1.和类明相同
//没有返回值
//定义有参构造后，如果想使用无参构造，显示定义一个无参的构造
//alt+insert，快捷键
}
/*
1.类与对象
类是一个模板
2.对象是通过引用来操作的： 栈——>堆
3.属性：字段Field 成员变量
默认初始化
数字：0 0.0
char：u0000
boolean：false
引用：null
4。修饰符 属性类型 属性名 =属性值
5. 必须使用new 关键字创造对象，构造器Person xiaoming =new Person（）；
对象的属性 xiaoming.name
对象的方法 xiaoming.sleep
6.类：
静态的属性
动态的方法
=------------------------
package com.f.www.object.oopDemo01;
public class Application {
public static void main(String[] args) {
Person person=new Person( "w");
System.out.println(person.name);
}
}
*/
2.封装（高内聚，低耦合）
1.private:定义私有属性关键字
2.get/set 提供public的get和set方法获取
3.alt+insert 自动生成get/set方法
package com.f.www.object.oopDemo01;
public class fengZhuangStudent {
//属性私有
private String name;
private int id;
private char sex;
//public的get/set方法
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
}
/*
属性私有 get/set
1.提高程序的安全性
2.隐藏代码的实现细节
3，统一接口
4.内部代码可提高程序的可维护性
package com.f.www.object.oopDemo01;
public class Application {
public static void main(String[] args) {
fengZhuangStudent student=new fengZhuangStudent();
student.setName("xiaoming");
System.out.println(student.getName());
}
}
*/
3.继承，方法重写，多态 instanceof关键字和类型转换（父类与子类的转换）
关键字：exrends意为扩展；
Object类，所以类都继承这个类
Super：超类
this：当前类
关键字： instanceof 判断是否有父子类关系
package com.f.www.object.oopDemo01;
import java.util.Objects;
public class JCStudent extends Person {
private String name1="QINGJIANG";
public void print(){
System.out.println(name);
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
@Override
public String toString() {
return "JCStudent{" +
"name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
//判断是否为同一个引用
if (this == o) return true;
//判断是否为同一个类型
if (o == null || getClass() != o.getClass()) return false;
// if (o instanceof JCStudent){}
JCStudent student = (JCStudent) o;
return Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name);
}
//gc();
@Override
protected void finalize() throws Throwable {
System.out.println("回收了"+
name1+" ");
}
}
//JAVA只有单继承，继承是类与类之间的关系
/*
super注意点
1.super调用父类的构造方法，必须在构造方法中的第一个
2.super只能出现在子类的方法或构造器中
3.super和this不能同时调用构造方法
区别：
代表·的对象不同
this：本身调用者这个对象
super：代表父类对象的引用
前提条件
this:没有继承也可以使用
super：只能在继承条件下才可以使用
构造方法
this();本类的构造
super();父类的构造
public static void main(String[] args) {
JCStudent student=new JCStudent();
student.say();
System.out.println(student.getMoney());
student.test("1");
*/
package com.f.www.object.oopDemo01;
public class methodsToRewrite {
/*
重写：需要继承关系，子类重写父类的方法 重写只针对非静态方法。静态方法没有重写一说。
方法名必须相同
参数列表必须相同
修饰符：范围可扩大，不能缩小 public>Protected>Default>private
抛出的异常：范围可以缩小，但不能扩大；classNotFoundException-->Exception（大）
A a=new A();
a.text();
//父类的引用指向了子类；
//Override 重写
B b=new A();
a.text();
Studnet S1=new Student（）；//Student 能调用的方法都是自己类里面的或是继承父类的
Person S2=new Student（）；//父类型，可以指向子类，但是不能调用子类独有的方法
Object S3=new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边大的·关系不大
（（Student）S2）.eat（）；//子类重写了父类的方法，执行子类的方法
多态：
1.多态是方法的多态，属性没有多态
2.父类和子类有联系，类型转换异常 ClassCastException
3.存在条件：继承关系，子类重写父类方法，父类指向子类对象
instanceof 判断是否存在父子关系
（（类型转换） 引用类型）.方法名（）；
（（Student）S2）.eat（）；
A a=new A();
a.text();
//父类的引用指向了子类；
//Override 重写
B b=new A();
a.text();
//System.out.println(X instanceof Y);//编译能不能通过
Object object= new JCStudent();
System.out.println(object instanceof JCStudent);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("---------------------");
Person person= new JCStudent();
System.out.println(person instanceof JCStudent);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(obj instanceof String);
JCStudent student=new JCStudent();
System.out.println(student instanceof JCStudent);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);
// System.out.println(student instanceof String);
父 子类型转换
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转换，强制转换
4.方便方法的调用，减少重复的代码
5.不能使用多态的情况{
static方法从属于类，不属于实例
final 常量
private 私有的
}
*/
}
4.static关键字
package com.f.www.object.oopDemo01;
import static java.lang.Math.*;//静态导入包
//static
public class staticTuozhan {
private static int age;//静态变量
private double score;//非静态的变量
{
//匿名代码块（在构造器之前）(用于赋初始值）
System.out.println("匿名代码块（在构造器之前）");
}
static {
//静态代码块（从属于类，只执行一次）
System.out.println("静态代码块（从属于类，只执行一次）");
}
public staticTuozhan() {
System.out.println("构造方法");
}
public void run(){
go();//非静态方法可以调用静态方法和本身方法
run();
}
public static void go() {
// run();//静态方法不可以调用非静态方法
}
public static void main(String[] args) {
staticTuozhan s=new staticTuozhan();
go();
System.out.println();
System.out.println(staticTuozhan.age);
// System.out.println(staticTuozhan.score);
System.out.println(s.age);
System.out.println(s.score);
System.out.println(random());//random()随机数
}
}
5.抽象类（abstract) 约束。
package com.f.www.object.oopDemo01;
public abstract class abstractClass {
//抽象类
public abstract void doit();//抽象方法
};
//1.不能new这个抽象类，只能靠子类去实现
//2.抽象方法必须在抽象类中，抽象类可以写普通方法
6.接口
1.接口本质是契约，约束。接口 不能通过new关键字出来，因为它不是类，可以通过implements实现多个接口，实现接口类，必须要重写接口中的方法。
package com.f.www.object.oopDemo01;
//实现接口的的类，需要重写接口中的方法
//implements 关键字
//多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void d() {
}
@Override
public void o() {
}
@Override
public void i() {
}
@Override
public void t() {
}
@Override
public void add() {
}
@Override
public void delete() {
}
@Override
public void update() {
}
@Override
public void queay() {
}
}
/*1.约束
2.定义一些方法，让不同的人实现
3.public abstract（方法都是抽象）
4.public static final
5.接口不能被实例化，接口中没有构造方法
6.implements可以实现多个接口
7.必须重写接口中的方法
*/\
7.内部类
内部类分为
1.成员内部类：在类的里面创建类
2.静态内部类：static关键字的类
3.局部内部类：方法里面创建类
4.匿名内部类：没有名字初始化类，不用将实例保存到变量中
package com.f.www.object.oopDemo02;
public class innerClass {
//外部类
private int id=10;
public void out (){
System.out.println("out class");
}
public class Inner {
//内部类
public void in(){
System.out.println("in class");
}
public void getId(){
//System.out.println(id);
}
//局部内部类
public void method(){
class Inner2{
public void in(){
}
}
}
}
}
/*
package com.f.www.object.oopDemo01;
import com.f.www.object.oopDemo02.innerClass;
import sun.applet.AppletClassLoader;
import java.sql.SQLOutput;
public class Application {
public void main(String[] args) {
innerClass out = new innerClass();
innerClass.Inner inner=out.new Inner(); //通过外部类的方法实例化内部类
inner.in();
inner.getId();
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
new UserService(){//匿名内部类
@Override
public void hello() {
}
};
}
class Apple{
public void eat(){
System.out.println("eat");
}
}
interface UserService{
void hello();
}
}
*/
8.Exception(异常）
1.检查性异常
2.运行时异常
3.错误Error
4.异常类的超类Throwable
5.try catch finally throw（方法里） throws（方法上） 异常机制关键字
package com.f.www.object.Exception;
import java.sql.SQLOutput;
public class Demo01{
public static void main(String[] args) {
int a = 1, b = 0;
try {
//try 监控区域
//ctrl+alt+T
//new Demo01().a();
System.out.println(a / b);
} catch (ArithmeticException e) {
//捕获区域 catch（想要捕获的异常类型）
System.out.println("chengxuyichang:b not 0");
}
catch(Exception e){
System.out.println("1");
}
catch (Error e) {
System.out.println("1");
}catch (Throwable e){
System.out.println("1");
}
finally {
//处理善后区域
System.out.println("finally");
}
// new Demo01().b();//异常示例
}
public void a(){
b();
}
public void b(){
a();
}
public void text(int a,int b)throws ArithmeticException{
if (b==0);{
throw new ArithmeticException();
}
}
}
/*
package com.f.www.object.oopDemo01;
import com.f.www.object.Exception.MyException;
public class Application {
static void test(int a)throws MyException {
System.out.println("传递的参数为"+a);
if(a>10){
throw new MyException(a);
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(99);
}catch (MyException e){
System.out.println("MyException=>"+e);
}
}
}
*/
/*
1.处理运行时异常时，采用逻辑去合理规避同事辅助Try-catch处理
2.在多重catch块后面可以加一个catch（Exception）来处理可能遗漏的异常
3.对于不确定的代码，也可以加上try-catch，处理潜在的异常
4.尽量去处理异常，切忌只是简单的调用PrintStackTrace（）去打印输出
5.具体如何处理异常，要跟据不同的业务需求和异常类型去解决
6.尽量添加finally语句去释放占用的资源
*/
自定义异常类，继承Exception，
package com.f.www.object.Exception;
//自定义异常类
public class MyException extends Exception {
public MyException(int a) {
this.detail = a;
}
//toString :异常信息的打印
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
private int detail;
}
测试类:
package com.f.www.object.oopDemo01;
import com.f.www.object.Exception.MyException;
public class Application {
static void test(int a)throws MyException {
System.out.println("传递的参数为"+a);
if(a>10){
throw new MyException(a);
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(99);
}catch (MyException e){
System.out.println("MyException=>"+e);
}
}
}
9.包装类(基本类型的引用类）
1.装箱和拆箱，jdk1.5之后提供自动拆箱和装箱
2.valueOf()静态方法
3.parseXXX();静态方法
4.基本类型与字符串之间的转换。
package com.f.www.object.oopDemo02;
import com.f.www.object.oopDemo01.JCStudent;
public class Class {
public static void main(String[] args) {
//getClass方法
JCStudent S1=new JCStudent();
JCStudent S2=new JCStudent();
//判断S1和S2是不是同一个类型
java.lang.Class Class1=S1.getClass();
java.lang.Class Class2=S2.getClass();
if(Class1==Class2){
System.out.println("s1和s2属于同一个类型");
}else{
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("-------------------");
//hashCode方法 内存地址的赋予
System.out.println(S1.hashCode());
System.out.println(S2.hashCode());
JCStudent S3=S1;
System.out.println(S3.hashCode());
System.out.println("-------------------");
//toString
System.out.println(S1.toString());
System.out.println("-------------------");
//equals方法
System.out.println(S1.equals(S2));
System.out.println("-------------------");
//finalize方法 //System.gc()；手动回收垃圾对象
//包装类八大基本类型
//类型转换装箱和拆箱
//装箱：基本类型转换为引用类型的过程
int num1=18;
//使用integer类
Integer integer=new Integer(num1);
Integer integer2=Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer);
//拆箱 引用类型转换为基本类型
Integer integer3=new Integer(100);
int num2=integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
//jdk1.5之后，提供自动装箱和拆箱
int age=4;
//自动装箱
Integer integer4= age;
System.out.println("自动装箱");
System.out.println(integer4);
//自动拆箱
int age2=integer4;
System.out.println("自动拆箱");
System.out.println(age2);
//基本类型和字符串之间的转换
//1，基本类型转字符串
int n1=100;
// 使用+连接符
String s1=n1+"";
//使用Integer中的toString（）方法
String s2=Integer.toString(n1);
System.out.println(s1);
//2.字符串转基本类型
String s="150";
//使用Integer.parxxx（）；
int n2=Integer.parseInt(s);
System.out.println(n2);
//boolean字符串形式转成基本类型，"true"-->"true" 非"true"--->false
String st1="true1";
boolean b1=Boolean.parseBoolean(st1);
System.out.println(b1);
}
}
10.整数缓冲区
1.整数缓冲区是堆预先创建内存大小为256字节的一个区域，范围在-128到127；整数缓冲区的创建是为了对已创建的对象重复利用。
11.String
1.字符串是常量，创建之后不可改变
2.字符串字面值储存在字符串常量池中，
常用方法
1.public int length();返回字符串的长度
2.public char charAt(in index)根据下标获取字符
3.public boolean contains（String str)判断当前字符串是否包含str
4.public char [] toCharArrays()将字符串转换成数组
5.public int indexOf(String str)查找str首次出现的下标，存在，则返回该下标，不存在，则返回-1；
6.public int lastIndexOf(String str)查找字符串当前字符串中最后一次出现的下标位置
7.public String trim()去掉字符串前后的空格
8.public String toUpperCase()将小写转换成大写，public String toLowerCase 将大写转换成小写
9.public boolean endWith(String str)判断字符串是否以str结尾public boolean startsWith(String str)判断是否以str开头
10.public String replace (char oldChar char newChar) 将字符串替换成新的字符串
11.public String []split (String str)根据str做拆分
12.equals()；比较数据 equalsIgnoreCase()忽略大小写比较
13.compare()；比较编码表位置顺序大小，位置相同比长度
实战案例
已知String str =“this is a text”;
1.将str中的单词单独获取出来
2.将str中的text替换为practice
3.在text前插入一个easy
4.将每个单词的首字母改为大写
12.StringBuffer可变长字符串jdk1.0就提供了，运行效率相对StringBuilder慢，线程安全(StringBuilder jdk1.5提供，运行效率快，线程不安全）
1.append()追加
2.insert()添加
3.replace ()替换
4.delete()删除
验证StringBuffer和StringBuilder的运行效率案例
13.bigDecimal
1.subtract（） 减法
2.add（）加法
3.multply（）乘法
4.divide（）除法
14.Date类、Calendar类、SimpleDateFormat类 System类
calendar方法
1.static Calendar getlnstance()使用默认时区和区域获取日历
2.void set（int year，int month, int day, int hourofday, int minute,int second, 设置日历的年、月、日、时、分、秒
3.int get（int field）返回给定的日历字段的值l
4.long getTimelnMilies毫秒为单位返回该日历的时间值
5.setTime()/getTime()可以实现Date和Calendar之间的转换
SimpleDateFormat方法是用来格式化和解析日期的具体类
进行格式化 （ 日期—>文本） 解析 （文本——>日期）
System类方法
1.static void arraycopy()复制数组
2.static long currentTimeMilies() 获取当前系统时间，返回的是毫秒值
3.static void gc（) 建议jvm赶快启动垃圾回收器回收垃圾
4.static void exit（int statius）退出jvm如果参数为0表示正常退出，非0表示异常退出
package com.f.www.object.oopDemo02;
import com.f.www.object.oopDemo01.JCStudent;
import org.w3c.dom.ls.LSOutput;
import javax.print.DocFlavor;
import java.math.BigDecimal;
import java.sql.SQLOutput;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
public class IntegerCache {
//整数缓冲
public static void main(String[] args) {
//-128-127 整数缓冲区，对已创建的对象重复利用
//String 是常量，不可变性
String name = "hello"; //hello 存储在常量池中，
name = "zhangsan";//zhangsan-赋值给变量name，给字符串赋值时，重新开辟了一个内存来存储zhangsan
String name2 = "zhangsan";
//字符串的存储
String str = new String("java是最好的编程语言");//在字符串池和堆里创建了两个对象
String str2 = new String("java是最好的编程语言");
System.out.println(str == str2);//false
System.out.println(str.equals(str2));//true
System.out.println("---------------------");
//字符串方法的使用
String content = "java , 是世界,最好的编程 java语言 , java真香";
//1.length();返回字符串的长度
System.out.println(content.length());
//2.chatAt(int index);返回某个位置的字符
System.out.println(content.charAt(content.length() - 1));
//3.contains(String str);判断是否包含某个子字符串
System.out.println(content.contains("java"));
System.out.println(content.contains("php"));
System.out.println("--------------");
//4.toCharArray();返回字符串对应的数组
System.out.println(Arrays.toString(content.toCharArray()));//Arrays.toString(content.toCharArray())已数组方式返回字符串
System.out.println(content.toCharArray());//toCharArray();返回字符串对应的数组
//5。indexOf();返回字符串首次出现的位置
System.out.println(content.indexOf("java", 4));
//6.lastIndexOf();返回字符串最后一次出现的位置
System.out.println(content.lastIndexOf("java"));
//7.trim();去掉字符串前后的空格
System.out.println("--------------");
String content2 = " hello word";
System.out.println(content2.trim());
//8.toUpperCase();把小写转换成大写//toLowerCase();把大写转换成小写
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
//9.endsWith(str);判断是否已str结尾//startsWith(str);判断是否已str开头；
String filename = "hello .java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("hello"));
System.out.println("---------------------");
//10.replace();用新的字符或字符串替换字符或字符串
System.out.println(content.replace("java", "php"));
//11.split();对字符串进行拆分
System.out.println(Arrays.toString(content.split("[ ,]+")));//[ ,]+指的是可以连续多个符号作为拆分符号，+指多个相同字符
System.out.println("----------------");
//equals 比较数据是否相同、compareTo();比较编码表的位置顺序大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));//equalsIgnoreCase 忽略大小写比较
String s3 = "abc";//97
String s4 = "xyzfwdwd";//120
System.out.println(s3.compareTo(s4));//s3位置减去s4的位置
String s5 = "abc";
String s6 = "abcabc";
System.out.println(s5.compareTo(s6));//比字符长度
System.out.println("-------------------");
//训练
String a = "this is a text";
String[] arr = a.split(" ");
for (String s : arr
) {
System.out.println(s);
}
System.out.println("---------------");
System.out.println(a.replace("text", "practice"));
System.out.println(a.replace("text", "easy text"));
System.out.println(a.length());
System.out.println(arr.length);
for (int i = 0; i < arr.length; i++) {
char charfrist = arr[i].charAt(0);
char two = Character.toUpperCase(charfrist);
String newarr = two + arr[i].substring(1);
System.out.println(newarr);
}
System.out.println("-----------");
//StringBuffer 运行效率慢线程安全 jdk1.5版本StringBuilder 运行速度快线程不安全 可变长字符串
//单线程使用StringBuilder
StringBuffer s=new StringBuffer();
//append();追加
s.append("java真香");
s.append("java好棒");
System.out.println(s.toString());
//insert(); 添加
s.insert(0,"best");
System.out.println(s.toString());
//replace(); 指定位置来替换
s.replace(0,5,"hello");
System.out.println(s.toString());
//delete();删除
s.delete(0,5);
System.out.println(s.toString());
//delete 清空
s.delete(0,s.length());
System.out.println(s.toString());
long start=System.currentTimeMillis();
/*String string=" ";
for (int i = 0; i < 999; i++) {
string+=i;
}
*/
StringBuilder stringBuilder=new StringBuilder();
for (int i = 0; i < 999; i++) {
stringBuilder.append(i);
}
System.out.println(stringBuilder);
long end=System.currentTimeMillis();
System.out.println("用时："+(end-start));
System.out.println("------------------");
double d1=1.0;
double d2=0.9;
System.out.println(d1-d2);
//BigDecimal, 大的浮点数精确计算
BigDecimal bd1=new BigDecimal("1.0");
BigDecimal bd2=new BigDecimal("0.9");
//subtract();减法
BigDecimal r1=bd1.subtract(bd2);
System.out.println(r1);
//add();加法
BigDecimal r2=bd1.add(bd2);
System.out.println(r2);
//multiply();乘法
BigDecimal r3=bd1.multiply(bd2);
System.out.println(r3);
System.out.println("------------");
//divide();除法
BigDecimal r4=new BigDecimal(10.1)
.subtract(new BigDecimal(1.1))
.divide (new BigDecimal(9.0),4,BigDecimal.ROUND_HALF_UP);
System.out.println(r4);
System.out.println("---------");
Date date=new Date();
//现在时间
System.out.println(date.toString());
System.out.println(date.toLocaleString());
//昨天时间
Date date2 = new Date(date.getTime()-60*60*1000);
System.out.println(date2.toLocaleString());
//after before
boolean b1=date.after(date2);
System.out.println(b1);
boolean b2=date.before(date2);
System.out.println(b2);
//compareTo();比较大小
int b=date.compareTo(date2);
System.out.println(b);// 检查毫秒值大为正1，相等为0，小为负1
//equals 比较是否相等
boolean bb2=date.equals(date2);
System.out.println(bb2);
//Calendar类
//1.创建一个Calendar对象
Calendar calendar=Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis());
//获取时间信息
int year=calendar.get(calendar.YEAR);
int month=calendar.get(calendar.MONTH);
int day=calendar.get(calendar.DAY_OF_MONTH);
int hour=calendar.get(calendar.HOUR_OF_DAY);
int minute=calendar.get(calendar.MINUTE);
int second =calendar.get(calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
//修改时间
Calendar calendar1=Calendar.getInstance();
calendar1.set(Calendar.DAY_OF_MONTH,6);//修改了月
System.out.println(calendar1.getTime().toLocaleString());
//add方法修改时间
calendar1.add(Calendar.HOUR_OF_DAY,5);
System.out.println(calendar1.getTime().toLocaleString());
int max=calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);//获取月中最大一天
int min= calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);//获取月中最小一天
System.out.println(max);
System.out.println(min);
System.out.println("----------");
//字符串转日期
/* SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日HH-mm-ss-SS"); //创建SimpleDateFormat
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd"); //创建SimpleDateFormat
Date date3=new Date();// 创建Date对象
String st=sdf.format(date);//格式化date
System.out.println(st);
//解析日期 把日期转换成字符串
Date de=sdf.parse("1999/11/22");
System.out.println(de);
*/
//System系统类 src原数组 srcPos从哪个位置复制；deat 目标数组；dest目标数组的位置；length 复制的长度；
int[]arrs={
1,23,43,4,2,233,32,44,444,22};
int[]dest=new int[15];
System.arraycopy(arrs,0,dest,3,arrs.length);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
// Arrays.copyOf();
//System.currentTimeMillis();
long start1=System.currentTimeMillis();
for (int i = -9999; i < 99999; i++) {
for (int j = -9999; j < 99999; j++) {
int result=i+j;
}
}
long end1=System.currentTimeMillis();
System.out.println("用时："+(end-start1));
//System.gc 回收
int name1=12;
String q1="woepp";
JCStudent jcStudent=new JCStudent();
System.gc();
//exit 退出jvm
System.exit(0);
}
}