标签：pow 实例 operation date 格式转化 block 运行时 second integer
Object是所有类的父类；可以是直接父类，也可以是间接父类
直接父类：如果一个类没有显示的extends关键字为显示指定父类，则该类默认继承Object父类。
间接父类：学生类继承了people类，people类默认继承Object类，这时候就为间接父类。
Object类常用方法
equals():比较俩个对象的地址
getClass()：返回运行时对象 ---百度了解
toString():字符串形式 ---百度了解
线程的
finaline():垃圾回收器调用的方法（final，finally，finalize三者区别）
final，finally，finalize三者区别？
final：修饰变量时，变量变为常量；修饰方法时，方法不能被重写；修饰一个类时，类不能被继承
finally：异常中使用
finaline:垃圾回收器调用的方法
notify():唤醒单个线程
notifyAll()：唤醒多个线程
wait()：线程等待
举例:
public class ObjectTest {
public static void main(String[] args) {
//对象是否相同
Object o1=new Object();
Object O2=new Object();
System.out.println(o1.equals(O2));
//getClass()返回运行时对象
MyInterface mi=getObject(2);
System.out.println("运行时对象："+mi.getClass());
}
//方法
public static MyInterface getObject(int i){
MyInterface mi=null;
if (i==1) {
return new MyImpl();
}else if(i==2){
return new MyImpl2();
}
return null;
}
}
//接口
public interface MyInterface {
void method();
}
//实现类
public class MyImpl implements MyInterface{
@Override
public void method() {
// TODO Auto-generated method stub
System.out.println("实现类实现了MyInterface接口");
}
}
public class MyImpl2 implements MyInterface{
@Override
public void method() {
// TODO Auto-generated method stub
System.out.println("实现类2实现了MyInterface接口");
}
}
(1)Java是面向对象的语言，但是其中有8种简单类型，不具备“对象”的特征，所以在Java为每个简单类型提供了包装类。(对象的特征包含属性和方法)
(2)八大基本数据类型对应各自的包装类(注意 int--->Interger、char--->Character)
byte--Byte
short-Short
int-Integer
long--Long
char-Character
float-Float
double-Double
boolean-Boolean
int age = 23;
double salary = 2678.5;
Integer in = new Integer(age); //装箱操作
Double sal= new Double(salary); //装箱操作
age = Integer .parseInt(in ); //拆箱操作
salary = Double.parseDouble(sal); //拆箱操作
Integer age = 23; //JDK1.5以后，自动装箱操作
Int in = age; // JDK1.5以后，自动拆箱操作
Math类中提供了常用的数学方法，这些方法大多数都是静态的
abs() 返回绝对值 abs(-1) 1
max() 返回两个参数的较大值 max(3,5) 5
min() 返回两个参数的较小值 min(3,5) 3
random() 返回0.0～1.0之间的double类型的随机数，包括0.0，但不包括1.0
random() [0.0,1.0)
round() 返回四舍五入的整数值 round(3.3) 3
sin() 正弦函数 sin(Math.PI/6) 约0.5
exp() 返回自然对数的幂 exp(3) 20.08553692318766
sqrt() 平方根函数 sqrt(4) 2
pow() 幂运算 pow(2,3) 8.0
Date类的常用方法
1） 获得当前的日期对象 Date date=new Date();
2） 获得给定毫秒的日期对象
方法一：Date date=new Date(long millis);
方法二：date.setTime(long millis);
3） 由日期对象获得对应的毫秒值 date.getTime()
举例：
----------------------1------------------------
import java.util.Date;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
// Date无参数构造-获取日期
public static void method(){
Date date=new Date();
//当前日期
System.out.println(date);
}
}
----------------------2------------------------
import java.util.Date;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
// Date无参数构造-获取日期
public static void method(){
//从1970年加上9000000L毫秒，算出的时间
Date date=new Date(90000000L);
//当前日期
System.out.println(date);
}
}
----------------------3------------------------
import java.util.Date;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
// Date 获取日期
public static void method(){
Date date=new Date();
//得到从1970年到现在为止的时间毫秒数
System.out.println(date.getTime());
}
}
----------------------4------------------------
import java.util.Date;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
// Date 获取日期
public static void method(){
Date date=new Date(1537234541360L);
//得到从1970年到现在为止的时间毫秒数，
System.out.println(date.getTime());
//加上（从1970年到现在为止的）时间毫秒数，生成现在时刻的日期
System.out.println(date);
}
}
DateFormat类是用来格式化和解析日期的具体类（是一个抽象类，不能直接new对象）
用法：格式化日期DateFormat.LONG
DateFormat df=DateFormat.getDateInstance(DateFormat.FULL);
String str=df.format(date);
System.out.println(str);
FULL：完全指定
SHORT:完全数字
MEDIUM:较长
LONG：更长
举例：
import java.text.DateFormat;
public class DateTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
method ();
}
//DateFormat 格式化日期
private static void method() {
Date date=new Date();//定义一个date类
DateFormat df=DateFormat.getDateInstance(DateFormat.FULL);
String str=df.format(date);
System.out.println();
}
}
SimpleDateFormat类可以自定义格式来格式化和解析日期的具体类
用法一：格式化日期
Date date=new Date();
String formate="yyyy年MM月dd日HH时mm分ss秒"; //定义字符串格式
SimpleDateFormat sdf=new SimpleDateFormat(formate); //把格式当做SimpleDateFormat类中构造方法的参数
String currentDate=sdf.format(date);
System.out.println("当前时间是："+currentDate);
举例：
import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
//SimpleDataFormat 用法一，格式化日期，返回是字符串。
private static void method() {
Date date=new Date();
String format="yyyy年MM月dd日hh时mm分ss秒";
String format2="yyyy年MM月dd日hh时mm分ss秒 EE";
String format3="EE";
SimpleDateFormat sdf=new SimpleDateFormat(format2);
String str=sdf.format(date);
System.out.println(str);
}
}
在“yyyy年MM月dd日HH时mm分ss秒”中：y表示年，M表示月，d表示日，H表示时，m表示分，s表示秒。
常用的格式化字符串有：yyyy-MM-dd、HH:mm:ss、yyyy/MM/dd、HH:mm:ss、yyyyMMddHHmmss。
注意:H表示24小时制 h为12小时制
用法二：将字符串转化成时间格式
String brithday=“2017-04-07";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date d=sdf.parse(brithday);
System.out.println("转换成Date类型的时间是："+d);
举例：
import java.util.Date
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
//SimpleDataFormat 用法二，把字符串格式转化为日期类型
private static void method4(){
String sdate="2008-10-1";
String format="yyyy-MM-dd";
SimpleDateFormat sdf=new SimpleDateFormat(format);
Date date=null;
try { //日期类型
date=sdf.parse(sdate);
System.out.println(date);
//如果希望把Date类型按照一定的格式输出，必须转为字符串
String str=sdf.format(date);
System.out.println(str);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Calendar类是一个日历类，可以修改，设置，修改日期。
Calendar的常用方法
add(int field,int amount) 给指定的日历字段添加或减去指定的时间量。
roll(int field,int amount) 与add方法类似区别在于加上amount后超过了该字段所能表示的最大范围时，也不会向上一个字段进位
set(int filed,int value) 将给定的日历字段设置为给定的值
set(int year,int month,int date) 设置Calendar对象的年、月、日三个字段的值
set(int year,int month,int date,int hourOfDate,int minute,intsecond) 设置Calendar对象的年、月、日、时、分、秒6个字段的值
举例：
import java.util.Calendar;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
method();
}
private static void method5(){
Calendar cal=Calendar.getInstance();
//获取当前日历的实例
System.out.println(cal.getTime());
//获取昨天的时间
cal.add(Calendar.DATE, -1);
System.out.println(cal.getTime());
//获取上个月时间
cal.add(Calendar.MONTH, -1);
System.out.println(cal.getTime());
//获取上一年时间
cal.add(Calendar.YEAR, -1);
System.out.println(cal.getTime());
}
}
在某些情况下，一个类的对象是有限而且固定的，比如季节类，固定只有4个对象。这种实例有限而且固定的类，在Java中被称为枚举类
实现：用enum关键字（它与class、inerface关键字的地位相同）来定义枚举类。枚举类是一种特殊的类，它一样有自己的成员变量和方法（并不继承Object类）
语法：
public enum SeasonEnum{
//定义四个季节
SPRING,SUMMER,FALL,WINTER;
}
//使用
SeasonEnum.SPRING
举例：
public enum SeanEnum {
spring,summer;//枚举的实例
}
public class Test {
SeanEnum sean=SeanEnum.summer;
}
其他特性可以到www.runoob.com/java/method-enum1.html查找
1）枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是默认继承了Object，因此枚举类不能再显示继承其他父类。
2)使用enum定义非抽象枚举类默认会使用final修饰，因此枚举类不能派生子类。
3)构造器只能是private
4)枚举类的所有实例必须在枚举类的第一行显示列出，否则这个枚举类永远都不能产生实例。
举例：
/*
* 枚举：实例是固定的
* 默认继承java.lang.Enum
* 构造方法只能private修饰
* 实例必须放在第一行，否则产生不了实例
* */
public enum SeanEnum {
spring(2),summer(3);//枚举的实例
private SeanEnum(int c){
}
}
5个常见的注释：
注解 描述
@Override 限定重写父类方法，它可以强制一个子类必须覆盖父类的方法。
@Deprecated 标示已过时，用于表示某个程序元素（类、方法）已过时，当程序原使用时，编译器会给出
警告。
@SuppressWarnings 指示该Annotation修饰的程序元素及该程序元素中的子元素取消显示指定的编译警告。
@SafeVarargs 用来抑制“堆污染”警告
@FunctionalIterface 检测接口为函数式接口，只能包含一个抽象方法
1）String：字符串是使用最频繁的内容
public int indexOf(int ch) 搜索第一个出现的字符ch（或字符串value）
public int indexOf(String value)
public int lastIndexOf(int ch) 搜索最后一个出现的字符ch（或字符value)
public int lastIndexOf(String 串value）
public String substring(int index) 提取从位置索引开始的字符串部分
public String substring(intbeginindex, int endindex)
提取beginindex和endindex之间的字符串部分
public String trim() 返回一个前后不含任何空格的调用字符串的副本
String类型的赋值方式
（a）采用字面直接赋值String s1 = “aaa”;
（b）构造方法赋值 String s2 = new String（“aaa”）;
（c）传递引用赋值 String s3 = s2;
如何比较s1,s2,s3的值？
可以用==比较地址是否相同，用equals比较字符串的内容是否相等。
2）StringBuffer：String增强版
String 类型的对象一旦被创建，存在在对象中的字符串序列是不允许被改变的。对字符串频繁修改（如字符串连接）时，就需要String不断创建对象，消耗大，效率低，所以应该使用StringBuffer类来提高修改效率。
常见的方法
方法 描述
toString() 转化成String类型
append() 追加字符串
insert() 插入字符串
length() 返回字符长度
3）StringBuilder类与StringBuffer的区别
StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是StringBuffer是线程安全的，而StringBuilder则没有实现线程安全的功能，所以性能略高
Lambda正则表达式
举例：
/**
* 资源不共享的情况
* @author dell
*
*/
public class Java8Test {
public static void main(String[] args) {
Java8Test jt=new Java8Test();
MathOperation operation=(a,b)->a-b;
System.out.println("a-b="+jt.operate(10, 2, operation));
MathOperation oper2=(a,b)->a+b;
System.out.println("a+b="+jt.operate(10, 2, oper2));
}
interface MathOperation {
int operation(int a, int b);
}
private int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
}
补充内容：www.runoob.com/java/method-enum1.html查找
标签：pow 实例 operation date 格式转化 block 运行时 second integer
原文地址：https://www.cnblogs.com/-lyr/p/9678821.html
