java入门基础一 1-14 之四类八种数据类型
java四类八种数据类型
四类:整数、浮点、字符、布尔
八种 : byte、short、int、long,float、double,char,boolean
三目运算符
公式 表达式1 ? 表达式2 : 表达式3; 真的取前面的,假的取其后面的;
例如: true时取0 ,假的取 currentPage。 true时取15,假的取 pageSize
其中"(a
Java中,&&与&,||与|的区别
在Java的逻辑运算符中,有这么四类:&&(短路与),&,|,||(短路或)。
&&和&都是表示与,区别是&&只要第一个条件不满足,后面条件就不再判断。而&要对所有的条件都进行判断。
|| 和 | 都是表示“或”,区别是||只要满足第一个条件,后面的条件就不再判断,而 | 要对所有的条件进行判断。
Day10 面向对象
Java中访问权限修饰符protected, default
public、 protected、 default和 private
A 、修饰符:
权限修饰符:private 、默认的(default)、protected、public
状态修饰符:static、final
抽象修饰符:abstract
B、类:
权限修饰符:默认的(default)、public
状态修饰符: final
抽象修饰符:abstract
C、成员变量(属性):
权限修饰符:private 、默认的(default)、protected、public 用的最多 private
状态修饰符:static、final
D、构造方法:
权限修饰符:private 、默认的(default)、protected、public 用的最多 public
E、成员方法:
权限修饰符:private 、默认的(default)、protected、public
状态修饰符:static、final
抽象修饰符:abstract
F、其他组合方式:
成员变量: public static fianl
成员方法: public static, public abstract, public final 。
成员内部类的面试题:
for循环
break,continue,return 的区别
for (int i = 1; i
if(i % 3 ==4 ){
//break; //跳出循环 (只针对循环内使用)
//continue; //终止本次循环继续下一次循环
//return; //跳出方法(在方法中使用)
}
//System.out.println("1111");
}
a: for (int i = 1; i < 10; i++) { // a: 控制跳转语句标号
System.out.println("i="+i);
b: for(int j = 1; j < 10;j++){
System.out.println("j="+j);
break a; //跳出a的for循环()
}
}
方法的重载
1.方法名相同,方法的参数列表不同,与返回值的类型无关。
重载的分类
1.参数个数不同
2.参数类型不同
3.顺序不同(一般不用)
数组
//动态初始化方式
int[] arr = new int[5];
System.out.println(arr[0]); //系统给出默认初始化值,int默认值是 0
整数类型 : byte, short , int , long ,默认初始化值都是 0。
浮点类型: float, double 默认初始化值都是 0.0.
布尔类型: boolean 默认值是 flase
字符类型:char 默认初始化值是 ' \u0000 ' 。
数组声明
一维数组
//静态初始化方式
int[] arrs = new int[] {11,22,33};
//不允许动静结合 例如: int[] arrs = new int[3] {11,22,33};
int[] arr1 ;
arr1 = new int[] {11,22,33}; //非简易声明和赋值可以不再同一行
int[] arr2 = {00,11,22,33}; //简易声明和赋值在同一行(用的较多)
二维数组
int[][] aa = new int[3][2]; //动态二维数组创建
int[] arra2[] = {{11,1},{22,2},{33,3}}; //静态二维数组创建
//二维数组的遍历
for (int i = 0; i < arra2.length; i++) {
System.out.print(arra2[i] +" 一位 ------------ ");
System.out.println();
//从二维数组中查找一维数组
for (int j = 0; j < arra2[i].length; j++) { //遍历一维数组
System.out.print(arra2[i][j] +" 二位 ");
}
System.out.println();
}
输出如下
//二维数组的相加
int sum = 0;
for (int i = 0; i < arra2.length; i++) { //从二维数组中查找一维数组
for (int j = 0; j < arra2[i].length; j++) { //遍历一维数组
sum = sum + arra2[i][j];
}
}
System.out.print(sum +" ");
this关键字
代表当前对象的引用;
应用场景:用来区分全局成员变量(属性)和局部变量重名
this必须有对象的时候才有值;即在创建对象的时候才有值;(this是随着对象的创建而存在)
构造方法
构造方法不能用对象调用
在一创建对象的时候,系统就帮我们调用了构造方法
作用:给对象的数据(属性)进行初始化
特点:方法名与类名相同(大小也要有一致)
没有返回值类型,连viod都没有;
没有具体的返回值return。
构造方法也是有return语句的,格式是( return ; )
给成员变量赋值的两种方式的区别
采用SetXxx的形式更多一些;
创建一个对象的步骤
static静态关键字
在静态方法中没有this关键字;(静态比对象先存在)
静态方法只能访问静态的成员变量和静态方法;(静态只能访问静态)
原因:非静态的方法或者成员变量只能通过创建对象调用,(有可能还没有创建对象)
而静态方法或者静态成员变量可以通过类名调用;
非静态方法可以访问静态(类名.)或者非静态(对象名.)的方法和成员变量;
当一个类中所有的方法都是静态方法的时候就要私有它的构造方法,
目的(不让其他类创建这个类的对象)
main方法
public static void main(String[] args){ }
public: 被jvm调用,所以需要足够大的权限
static:被jvm调用不需要创建对象,直接类名调用即可;
void: 被jvm调用不需要任何返回值;
main: 只有这样写才能被jvm识别,main不是关键字
Math.random()伪随机数
//Math.random()会生成大于等于0.0 并且小于 1.0的伪随机数 生成1到100的随机数
for (int i = 0; i < 10; i++) {
System.out.println((int)(100*Math.random())+1);
}
Day08面向对象
//构造代码块(初始化块) 而且优先于构造方法(函数)执行
// 在类中方法外出现;多个构造方法中相同的代码存放在一起;每次调用构造都执行,并且在构造方法前执行;
//作用: 构造代码块每次创建一次对象就会执行一次;先走构造代码块,再走构造方法;
//静态代码块 优先于主方法执行的,
// 在类中方法外出现,加了static修饰; 静态代码块是随着类的加载而加载,而且只执行一次,
//作用:用来给类进行初始化,一般用来加载驱动;
继承
优点:
提高了代码的复合性,
提高了代码的维护性,
让类于类之间产生了关系,是多态的前提
缺点: 类的耦合性增强了,
开发的原则是:高内聚(就是自己完成某件事的能力)、低耦合(类于类之间的关系)。
继承特点:只支持单继承,支持多层继承。
子类只能继承父类中所有非私有的成员。
子类不能继承父类的构造方法(原因:构造方法名和类名是同名,),但是可以通过super关键字区访问父类的构造方法,
什么时候使用继承:
继承是体现一种关系:is a 。
如果有两个类A 、B,中有他们复合A是B的一种,或者B是A的一种,就可以使用继承。
成员变量的关系:子父类出现同名的变量时,子类区调用父类的成员时,同名的时候就不会调用该成员,原因是子类中有该成员,会 就近原则取值。(实际开发时是不会出现这个问题的,)
this和super关键字区别:
this: 即可以调用本类的成员,也可以调用父类的成员(在本类中没有的情况下);
super 调用父类的成员,
super() 语句,如果不写,系统会默认加上,用来访问父类中的空参构造方法。
每个构造方法的第一条语句默认都是 super(); 子类的父类 访问最大object父类
原因:子类会继承父类的数据,可能还是使用父类的数据。所以子类初始化之前,一定要先完成父类数据的初始化。
静态代码块、构造代码块和构造方法执行的先后顺序
/*
1.jvm 调用main方法,main进栈
2.遇到Zi z =new Zi(); 会先将Fu.class和Zi.class分别加载到内存,再创建对象,
当Fu.class加载进内存, 父类的静态代码块会随着Fu.class一起加载,
当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载,
第一个输出 父类静态代码块fu 第二个输出 子类静态代码块zi
3.走子类的构造方法 super(); Java是分层执行的, 先初始化父类再初始化子类, 所以会先走父类的构造,
在执行父类的构造时发现父类有 父类构造代码块 fu,(构造代码块是优先于构造方法先执行 )
第三个输出是 父类构造代码 ---块 ---fu, 第四个输出 父类构造方法fu,
4.父类初始化完成, 子类初始化,第五个输出 子类构造代码 ---块 ---zi ,
第六个输出 子类构造方法zi
*/
重写
定义:子类重写父类的方法;子类中出现和父类中方法声明一模一样的方法,与返回值值类型有关,返回值是一致的;
父类中私有方法不能被重写;原因:父类中私有的方法子类根本就无法继承,
子类重写父类方法时 子类的访问权限要大于或等于父类(最好是相等);
方法的重载
定义:1.方法名相同,方法的参数列表不同,与返回值的类型无关。
重载的分类
1.参数个数不同
2.参数类型不同
3.顺序不同(一般不用)
子类对象调用父类方法的时候先找本身,再找父类(就近原则);
final关键字
final修饰特点:一般与public static 共用
修饰类:类不能被继承;
修饰变量:变量就变成了常量,只能被赋值一次;
修饰方法:方法不能被重写。
基本数据类型: 是值不能被改变;
引用数据类型:是地址值不能被改变,对象中的属性可以改变。
Day09面向对象
多态 : 食物存在的分种状态;
多态的前提:
1.要有继续关系,
2.要有方法的重写,
3.要有父类引用指向子类对象
Father f = new Son();
成员变量: 编译看左边(父类),运行看左边(父类)。
静态方法: 编译看左边(父类),运行看左边(父类)。
成员方法(普通方法): 编译看左边(父类),运行看右边(子类)。又叫(动态绑定)。
多态的好处
提高了代码的维护性(继承保证);
提高了代码的扩展性(由多态保证);
强制向下转型关键字:instanceof 判断前面的引用是否是后面的数据类型
抽象类
特点
抽象类或者方法必须用 abstract 关键字修饰
抽象类不一定有抽象方法,有抽象方法的一定是抽象类或者是接口;
抽象类不能实例化(即不能创建对象, 那怎么实现抽象类的实例化呢?
按照多态的方式,由具体的子类实例化,其实这也是多态的一种,抽象类多态。
抽象类的子类
要么是抽象的
要么重写抽象类中的所有抽象方法。
抽象类的成员方法特点:
抽象方法: 强制要求子类做的事情;
非抽象方法: 子类继承的事情,提高代码的复用性。
抽象类中可以定义构造方法,
抽象类中可以不定义抽象方法,意义:不让其他类创建本类的对象,交给子类完成。
abstract 不能和 stratic 关键字共存。
原因:类名.抽象方法的调用是没有意义,抽象方法没有方法体
abstract 不能和 final 关键字共存。
原因:被 abstract 修饰的方法会强制子类重写;被 final 修饰的方法是不让子类重写,所在他俩是矛盾的。
abstract 不能和 private 关键与共存。
原因:被 abstract 修饰的方法是为了子类看到并继承的; 被 private 修饰的不让子类访问,所以他俩是矛盾的。
接口 : 关键字 interface
接口不能被实例化,调用抽象方法没有意义;
可以按照多态的方式实例化 接口 接口名 = new 接口实现类();
接口的子类:
可以是抽象类,意义不大。
可以是具体类,要重写接口中的所有抽象方法。(推荐使用)
在接口中可以定义成员变量 int num =10 ; 但只能是常量并且是静态的公共的 , 没意义;
成员变量的默认修饰符: public static final (三个关键字没有顺序要求), 建议手动添加上。
接口没有构造方法;
接口中的方法:只能是抽象方法;
默认是修饰符 public abstract;
类与类,类与接口,接口与接口的关系:单继承多实现。
类与类是继承关系,只能是单继承,可以多层继承。
类与接口是实现关系,多实现,通过 , 隔开。
接口与接口是继承关系,可以单继承,也可以多继承。
接口和抽象类的区别:
1、成员区别
A 、抽象类
成员方法,可以是变量,可以是常量。
构造方法: 有
成员方法: 可以是抽象方法,可以是普通方法;
B、 接口:
成员方法,只能是常量。
构造方法: 没有
成员方法: 只能是抽象方法;
2、关系区别: 类与 类是继承关系,类与接口是实现关系,接口与接口是单继承或多继承。
3、设计理念区别:
A、抽象类是 is-a 的关系 抽象类中定义是该继承体系的共性功能。是一个 继承关系
B、接口是 like-a 的关系 接口中定义是该继承体系的扩展功能。 像一个 组合关系
Day11Eclipse开发工具和API
MyEclipse开发快捷键:
导包:Art + /;
查看源码 : 选中类名 ( 按F3或者Ctrl+鼠标点击),
上下移动:Art + 上下箭头;
查找具体类:Ctrl + Ctrl + Shift + t ;
Art+Shift + R : 选中一个后点击 Art+Shift + R 会把后面的同名也选中,比较方便
查找具体方法:Ctrl + O;
给建议:Ctrl+ 1 根据右边生成左边的数据类型,生成方法;
删除代码:选中后Ctrl + d;
抽取方法: Art + Shift + m;
修改名字(类、方法)Art+Shift+ r 。
自动生成有无参构造方法和set、get方法:Art + Shift + S;
代码快速复制: Ctrl + Art + / ;
tostring() 方法:toString是Object类的方法,所有类都从Object类继承。如果你定义的类没有覆盖toString方法,则对象在调用toString方法时用的是Object类toString方法,返回的是“类名@hashcode".
当有非字符型数据要转换成字符串类型时,一个toString()方法即可将类型进行转换
如果StringBuffer想要输出的话,则必须用toString()方法先转换成String类型,才能输出
因为它是Object里面已经有了的方法,而所有类都是继承Object,所以“所有对象都有这个方法”。
它通常只是为了方便输出,比如System.out.println(xx),括号里面的“xx”如果不是String类型的话,就自动调用xx的toString()方法
总而言之,它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法
写这个方法的用途就是为了方便操作,所以在文件操作里面可用可不用
equals()方法和 == 的区别:
共同点:都可以做比较,返回值都是 boolean 类型;
区别:1、 == 是比较运算符,既可以比较基本数据类型,又可以比较引用数据类型,基本数据类型
是 比较的值, 引用数据类型是比较的地址值;
2、 equals方法只能比较引用数据类型,equals()方法在没重写之前比较的是地址值,底层依
赖的是 == 号,但是比较地址值是没有意义的,我们需要重写equals方法比较对象中的属
性值。
Day11常见对象:
String类:
字符串是常量(final修饰),一旦被赋值 就不能被改变。
A:常见构造方法
* public String():空构造
* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串
public static void main(String[] args) {
String s1 = new String();
System.out.println(s1);
byte[] arr1 = {97,98,99};
String s2 = new String(arr1); //解码,将计算机读的懂的转换成我们读的懂
System.out.println(s2);
byte[] arr2 = {97,98,99,100,101,102};
String s3 = new String(arr2,2,3); //将arr2字节数组从2索引开始转换3个
System.out.println(s3); 输出cde 从第二开始计算3个,包括第二个
char[] arr3 = {'a','b','c','d','e'}; //将字符数组转换成字符串
String s4 = new String(arr3);
System.out.println(s4);
String s5 = new String(arr3,1,3); //将arr3字符数组,从1索引开始转换3个
System.out.println(s5);
String s6 = new String("heima");
System.out.println(s6);
* A:String类的判断功能
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
* boolean contains(String str):判断大字符串中是否包含小字符串
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
* boolean isEmpty():判断字符串是否为空。
" "与null的区别:
" "是字符串常量,同时也是一个String类的对象,既然是对象当然可以调用String类中的方法;
null 是空常量,不能调用任何的方法,否则会出现空指针异常,null常量可以给任意的引用数据类型赋值。
* A:String类的获取功能
* int length():获取字符串的长度。
* char charAt(int index):获取指定索引位置的字符
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索
引。
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处
的索引。
* lastIndexOf
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包含头,不包含尾,左闭右开
迷惑题
String类的转换功能:
* byte[] getBytes():把字符串转换为字节数组。
String a ="abc";
byte[] arra = a.getBytes();
for (int i = 0; i < arra.length; i++) {
System.out.print (arra[i]+" ");//输出97 98 99
}
* char[] toCharArray():把字符串转换为字符数组。
String a ="heima";
char[] a1 = a.toCharArray();
for (int i = 0; i < a1.length; i++) {
System.out.print (a1[i]+" "); //输出 h e i m a
}
* static String valueOf(char[] chs):把字符数组转成字符串。
char[] arra = {'a','b','c'};
String a1 = String.valueOf(arra);
System.out.println(a1); //输出 abc
* static String valueOf(int i):把int类型的数据转成字符串。
String ints = String.valueOf(100);
System.out.println(ints + 100); // 输出 100100
* 注意:String类的valueOf方法可以把任意类型的数据转成字符串。
常见对象(String类的其他功能)
String的去除字符串两端空格及案例演示 String trim()
String s = " hei ma ";
//String的去除字符串两端空格及案例演示 String trim()
String s2 = s.trim();
System.out.println(s2); //輸出 “hei ma”
//倒叙输出字符串
String arr = "abc"; //添加一个字符串
char[] a1 =arr.toCharArray(); //将字符型转换成数组;
String s = ""; //定义一个空字符串
for(int i=a1.length-1;i >=0;i-- ){ //倒叙遍历数组
s= s + a1[i];
}
System.out.println(s); //输出 cba
统计大串中小串出现的次数
Day12常见对象:
线程安全效率低,线程不安全效率高。
* B:StringBuffer和String的区别
* String是一个不可变的字符序列
* StringBuffer是一个可变的字符序列
StringBuffer线程安全的,效率低
StringBuffer sb3 = new StringBuffer();
System.out.println(sb3); // 输出 空值
System.out.println(sb3.toString()); //输出 空值 说明StringBuffer重写了toString方法。
* A:StringBuffer的添加功能
* public StringBuffer append(String str):
* 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
验证 StringBuffer sb = new StringBuffer(); // 只new 创建一个对象
StringBuffer sb2 = sb.append(true); //sb sb2 sb3 sb4 指向同一个内存地址
StringBuffer sb3 = sb.append("heima");
StringBuffer sb4 = sb.append(100);
System.out.println(sb); //输出trueheima100
System.out.println(sb2); //输出trueheima100
System.out.println(sb3); //输出trueheima100
System.out.println(sb4); //输出trueheima100
//StringBuffer是字符串缓冲区,当new的时候在堆内创建一个对象,
//底层是一个长度为16的字符数组,当调用添加的方法时,不会再重新创建对象,
//在不断向原缓冲区添加字符。
* public StringBuffer insert(int offset,String str):
* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
StringBuffer 的insert方法 功能: 添加
StringBuffer sb = new StringBuffer();
sb.insert(3,"heima");
//插入数据 3 代表位置 heima 代表插入的数据。 因为0、1、2、的位置是空值
//所以输出 字符串下标越界错误 输出 StringIndexOutOfBoundsException
System.out.println(sb);
StringBuffer sb = new StringBuffer("1234");
sb.insert(3,"heima");
System.out.println(sb);//输出 123heima4 在3的下标添加
StringBuffer 的deleteCharAt方法 功能:
StringBuffer sb = new StringBuffer("1234");
sb.deleteCharAt(5);
System.out.println(sb); //报 越界异常 StringIndexOutOfBoundsException
sb.deleteCharAt(3);
System.out.println(sb); // 输出123
StringBuffer 的delete方法 功能: 删除
StringBuffer sb = new StringBuffer("heima");
sb.delete(0, 2);
System.out.println(sb); //输出 ima 包含头,不包含尾
清空缓冲区
StringBuffer sb = new StringBuffer("heima");
sb.delete(0,sb.length()); //清空缓冲区
System.out.println(sb);
StringBuffer 的replace和reverse方法 功能: 替换和反转
StringBuffer sb = new StringBuffer("heima");
sb.replace(0, 3,"bai"); //包含头,不包含尾
System.out.println(sb); //输出 baima
sb.reverse(); //倒叙输出方法
System.out.println(sb); //输出amieh
StringBuilder线程不安全,效率高 ,其方法与StringBuffer一样
String 与 StringBuffer 和StringBuilder的区别:
String是一个不可变的字符序列;
StringBuffer 和StringBuilder是可变的字符序列
StringBuffer 和StringBuilder 的区别:
StringBuffer 是线程安全的,效率低;
StringBuilder 是线程不安全的,效率高;
Day13常见对象:
冒泡排序
int[] arr = {50,80,30,10,100}; //声明一个数组
for (int i = 0; i < arr.length - 1; i++) { //外循环是比较的循环次数
for (int j = 0; j < arr.length -1 -i ; j++) { //内层循环控制每一趟排序多少次
//减i是为了提高效率,减1是为了下标越界 内循环是把数组元素的作对比
if(arr[j]> arr[j+1]){ //通过if判断前后数组元素的大小 把大值交换到前面
int tem = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tem;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+ " ");
}
Arrays类的方法和概述:
sort() 排序方法:
int[] arr = {11,33,55,22,44,66,10};
System.out.println(Arrays.toString(arr)); //输出 [11, 33, 55, 22, 44, 66, 10]
Arrays.sort(arr); //排序方法
System.out.println(Arrays.toString(arr)); //输出 [10, 11, 22, 33, 44, 55, 66]
binarySearch() 方法 查找
int[] a = {10,22,30,45,55,65,99};
System.out.println(Arrays.binarySearch(a,99)); //输出6 按照下标位置输出
基本数据类型的包装类
* C:基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer类
System.out.println(Integer.toBinaryString(60)); // 转换二进制 输出 111100
System.out.println(Integer.toOctalString(60)); // 转换八进制 输出 74
System.out.println(Integer.toHexString(60)); // 转换十六进制 输出 3c
System.out.println(Integer.MAX_VALUE); //2的31次方-1 输出2147483647
System.out.println(Integer.MIN_VALUE); //-2的31次方 输出-2147483648
Integer的面试题:
Integer a1 = new Integer(100);
Integer a2 = new Integer(100);
System.out.println(a1 == a2); //false
System.out.println(a1.equals(a2)); //true
//equals()方法
//比较此对象与指定对象。当且仅当参数不为 null, 并且是一个与该对象包含相同 int 值的 Integer 对象时,结果为 true
Integer a3 = 128; //大于等于128就为false
Integer a4 = 128; //大于等于128就为false
System.out.println(a3 == a4); //false
System.out.println(a3.equals(a4)); //true
//因为-128 到127 是byte的取值范围,如果在这个范围内取值 ,自动装箱就不会创建对象;
//而是从常量池中取值,
//如果超过了byte取值范围就会再创建新对象。
Day14简单看了一遍:
在一个源文件中不能出现两个public 修饰的class类文件,可以有多个类,但不能用两个public修饰
system类
finalize()方法
当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。子类重写 finalize 方法,以配置系统资源或执行其他清除。
system.gc() 运行垃圾回收器会调用fianlize()方法去清理垃圾(相当于呼喊保洁阿姨清理垃圾)
exit()方法 非0状态是异常退出,退出jvm
终止当前正在运行的 Java 虚拟机。参数用作状态码;根据惯例,非零的状态码表示异常终止
currentTimeMillis()方法 获取当前系统时间
当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差(以毫秒为单位测量);
long start = System.currentTimeMillis(); //开始时间
for (int i = 0; i < 1000; i++) {
System.out.println("*");
}
long end = System.currentTimeMillis(); //结束时间
System.out.println(end - start);
arraycopy()方法 数组拷贝;
//从原数组中赋值一个数组,复制从指定的位置开始,到目标数组的指定位置结束。
int[] src = {11,22,33,44,55};
int[] dest =new int[8];
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+" "); //输出 0 0 0 0 0 0 0 0
}
System.arraycopy(src, 0, dest, 0, src.length);
//原数组 ,原数组起始位置,新数组,新数组起始位置,原数组长度。
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+" "); //输出 11 22 33 44 55 0 0 0
}
Date 类 的使用方法:
Date d = new Date();// 不传入参数 代表 系统当前时间 使用 无参构造
System.out.println(d); //输出系统当前时间Tue Jul 25 22:50:30 CST 2017
Date d1 = new Date(0); // 传入任何参数输出一样 使用 有参构造 通过毫秒值创建时间对象
System.out.println(d1);
//输出 Thu Jan 01 08:00:00 CST 1970 系统默认规定的时间 , 08:00:00是北京东八区
setTime()方法设置毫秒值
Date d = new Date();
d.setTime(1000); //设置毫秒值 改变时间对象
System.out.println(d); //输出: Thu Jan 01 08:00:01 CST 1970 输出 起始时间
SimpleDateFormat 类的是用和讲述
format() 方法:
Date d = new Date(); //获取时间
SimpleDateFormat sd = new SimpleDateFormat(
"yyyy年MM月dd日 HH时:mm分:ss秒"); //创建日期格式化对象
System.out.println(sd.format(d)); //将日期格式转换为字符串
parse()方法
//将字符串转换成日期格式.
String str = "2010年10月10日 10:10:10"; //上下格式一定要完全相同,空格都不能相差。
SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = sd.parse(str);
System.out.println(d); 垃圾
Calendar 类
add()方法、 set()方法
Calendar c = Calendar.getInstance();
c.add(Calendar.MONTH, 1); //可以添加年、月、日, c.add(年月日,添加数);
c.set(Calendar.MONTH, 1); //可以设置年 、月、日 c.set(年月日, 设置数)
System.out.println(c.get(Calendar.MONTH));
代码如下:
java四类八种数据类型四类:整数、浮点、字符、布尔八种 : byte、short、int、long,float、double,char,boolean三目运算符
公式 表达式1 ? 表达式2 : 表达式3; 真的取前面的,假的取其后面的;
例如: true时取0 ,假的取 currentPage。 true时取15,假的取 pageSize
其中"(a<b)?a:b"是一个"条件表达式",它是这样执行的:如果a<b为真,则表达式取a值,否则取b值. Java中,&&与&,||与|的区别
在Java的逻辑运算符中,有这么四类:&&(短路与),&,|,||(短路或)。
&&和&都是表示与,区别是&&只要第一个条件不满足,后面条件就不再判断。而&要对所有的条件都进行判断。 || 和 | 都是表示“或”,区别是||只要满足第一个条件,后面的条件就不再判断,而 | 要对所有的条件进行判断。Day10 面向对象
Java中访问权限修饰符protected, default
public、 protected、 default和 privateA 、修饰符:权限修饰符:private 、默认的(default)、protected、public状态修饰符:static、final抽象修饰符:abstract
B、类:权限修饰符:默认的(default)、public状态修饰符: final抽象修饰符:abstract
C、成员变量(属性):权限修饰符:private 、默认的(default)、protected、public 用的最多 private状态修饰符:static、final
D、构造方法:权限修饰符:private 、默认的(default)、protected、public 用的最多 public
E、成员方法: 权限修饰符:private 、默认的(default)、protected、public状态修饰符:static、final抽象修饰符:abstract
F、其他组合方式:成员变量: public static fianl 成员方法: public static, public abstract, public final 。
成员内部类的面试题:for循环break,continue,return 的区别
for (int i = 1; i <= 10; i++) {if(i % 3 ==4 ){//break; //跳出循环 (只针对循环内使用)//continue; //终止本次循环继续下一次循环//return; //跳出方法(在方法中使用)}//System.out.println("1111");}a: for (int i = 1; i < 10; i++) { // a: 控制跳转语句标号System.out.println("i="+i);b: for(int j = 1; j < 10;j++){System.out.println("j="+j);break a; //跳出a的for循环()}}
方法的重载
1.方法名相同,方法的参数列表不同,与返回值的类型无关。
重载的分类
1.参数个数不同
2.参数类型不同
3.顺序不同(一般不用)数组//动态初始化方式int[] arr = new int[5];System.out.println(arr[0]); //系统给出默认初始化值,int默认值是 0
整数类型 : byte, short , int , long ,默认初始化值都是 0。
浮点类型: float, double 默认初始化值都是 0.0.
布尔类型: boolean 默认值是 flase
字符类型:char 默认初始化值是 ' \u0000 ' 。
数组声明 一维数组//静态初始化方式
int[] arrs = new int[] {11,22,33};
//不允许动静结合 例如: int[] arrs = new int[3] {11,22,33};
int[] arr1 ;
arr1 = new int[] {11,22,33}; //非简易声明和赋值可以不再同一行int[] arr2 = {00,11,22,33}; //简易声明和赋值在同一行(用的较多)二维数组int[][] aa = new int[3][2]; //动态二维数组创建
int[] arra2[] = {{11,1},{22,2},{33,3}}; //静态二维数组创建
//二维数组的遍历
for (int i = 0; i < arra2.length; i++) {System.out.print(arra2[i] +" 一位 ------------ ");System.out.println();//从二维数组中查找一维数组for (int j = 0; j < arra2[i].length; j++) { //遍历一维数组System.out.print(arra2[i][j] +" 二位 ");}System.out.println();
}
输出如下//二维数组的相加
int sum = 0;for (int i = 0; i < arra2.length; i++) { //从二维数组中查找一维数组for (int j = 0; j < arra2[i].length; j++) { //遍历一维数组sum = sum + arra2[i][j]; } } System.out.print(sum +" ");this关键字
代表当前对象的引用;
应用场景:用来区分全局成员变量(属性)和局部变量重名
this必须有对象的时候才有值;即在创建对象的时候才有值;(this是随着对象的创建而存在)
构造方法
构造方法不能用对象调用
在一创建对象的时候,系统就帮我们调用了构造方法
作用:给对象的数据(属性)进行初始化
特点:方法名与类名相同(大小也要有一致)
没有返回值类型,连viod都没有;
没有具体的返回值return。
构造方法也是有return语句的,格式是( return ; )
给成员变量赋值的两种方式的区别采用SetXxx的形式更多一些;创建一个对象的步骤static静态关键字在静态方法中没有this关键字;(静态比对象先存在)
静态方法只能访问静态的成员变量和静态方法;(静态只能访问静态)
原因:非静态的方法或者成员变量只能通过创建对象调用,(有可能还没有创建对象)
而静态方法或者静态成员变量可以通过类名调用;
非静态方法可以访问静态(类名.)或者非静态(对象名.)的方法和成员变量;
当一个类中所有的方法都是静态方法的时候就要私有它的构造方法,
目的(不让其他类创建这个类的对象)
main方法
public static void main(String[] args){ }
public: 被jvm调用,所以需要足够大的权限
static:被jvm调用不需要创建对象,直接类名调用即可;
void: 被jvm调用不需要任何返回值;
main: 只有这样写才能被jvm识别,main不是关键字Math.random()伪随机数
//Math.random()会生成大于等于0.0 并且小于 1.0的伪随机数 生成1到100的随机数for (int i = 0; i < 10; i++) {System.out.println((int)(100*Math.random())+1);}Day08面向对象
//构造代码块(初始化块) 而且优先于构造方法(函数)执行 // 在类中方法外出现;多个构造方法中相同的代码存放在一起;每次调用构造都执行,并且在构造方法前执行;//作用: 构造代码块每次创建一次对象就会执行一次;先走构造代码块,再走构造方法;//静态代码块 优先于主方法执行的,// 在类中方法外出现,加了static修饰; 静态代码块是随着类的加载而加载,而且只执行一次,//作用:用来给类进行初始化,一般用来加载驱动;
继承优点:提高了代码的复合性,提高了代码的维护性,
让类于类之间产生了关系,是多态的前提缺点: 类的耦合性增强了,
开发的原则是:高内聚(就是自己完成某件事的能力)、低耦合(类于类之间的关系)。
继承特点:只支持单继承,支持多层继承。
子类只能继承父类中所有非私有的成员。
子类不能继承父类的构造方法(原因:构造方法名和类名是同名,),但是可以通过super关键字区访问父类的构造方法,
什么时候使用继承:
继承是体现一种关系:is a 。
如果有两个类A 、B,中有他们复合A是B的一种,或者B是A的一种,就可以使用继承。
成员变量的关系:子父类出现同名的变量时,子类区调用父类的成员时,同名的时候就不会调用该成员,原因是子类中有该成员,会 就近原则取值。(实际开发时是不会出现这个问题的,)
this和super关键字区别:this: 即可以调用本类的成员,也可以调用父类的成员(在本类中没有的情况下);
super 调用父类的成员,super() 语句,如果不写,系统会默认加上,用来访问父类中的空参构造方法。
每个构造方法的第一条语句默认都是 super(); 子类的父类 访问最大object父类
原因:子类会继承父类的数据,可能还是使用父类的数据。所以子类初始化之前,一定要先完成父类数据的初始化。
静态代码块、构造代码块和构造方法执行的先后顺序/*
1.jvm 调用main方法,main进栈
2.遇到Zi z =new Zi(); 会先将Fu.class和Zi.class分别加载到内存,再创建对象,当Fu.class加载进内存, 父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载,第一个输出 父类静态代码块fu 第二个输出 子类静态代码块zi
3.走子类的构造方法 super(); Java是分层执行的, 先初始化父类再初始化子类, 所以会先走父类的构造,在执行父类的构造时发现父类有 父类构造代码块 fu,(构造代码块是优先于构造方法先执行 )第三个输出是 父类构造代码 ---块 ---fu, 第四个输出 父类构造方法fu,
4.父类初始化完成, 子类初始化,第五个输出 子类构造代码 ---块 ---zi ,第六个输出 子类构造方法zi
*/重写
定义:子类重写父类的方法;子类中出现和父类中方法声明一模一样的方法,与返回值值类型有关,返回值是一致的;
父类中私有方法不能被重写;原因:父类中私有的方法子类根本就无法继承,
子类重写父类方法时 子类的访问权限要大于或等于父类(最好是相等);方法的重载
定义:1.方法名相同,方法的参数列表不同,与返回值的类型无关。
重载的分类
1.参数个数不同
2.参数类型不同
3.顺序不同(一般不用)子类对象调用父类方法的时候先找本身,再找父类(就近原则);final关键字
final修饰特点:一般与public static 共用修饰类:类不能被继承;修饰变量:变量就变成了常量,只能被赋值一次;修饰方法:方法不能被重写。
基本数据类型: 是值不能被改变;
引用数据类型:是地址值不能被改变,对象中的属性可以改变。Day09面向对象多态 : 食物存在的分种状态;多态的前提:1.要有继续关系,2.要有方法的重写,3.要有父类引用指向子类对象Father f = new Son();
成员变量: 编译看左边(父类),运行看左边(父类)。
静态方法: 编译看左边(父类),运行看左边(父类)。
成员方法(普通方法): 编译看左边(父类),运行看右边(子类)。又叫(动态绑定)。
多态的好处
提高了代码的维护性(继承保证);
提高了代码的扩展性(由多态保证);
强制向下转型关键字:instanceof 判断前面的引用是否是后面的数据类型
抽象类特点抽象类或者方法必须用 abstract 关键字修饰 抽象类不一定有抽象方法,有抽象方法的一定是抽象类或者是接口;抽象类不能实例化(即不能创建对象, 那怎么实现抽象类的实例化呢?按照多态的方式,由具体的子类实例化,其实这也是多态的一种,抽象类多态。
抽象类的子类要么是抽象的要么重写抽象类中的所有抽象方法。抽象类的成员方法特点:抽象方法: 强制要求子类做的事情;非抽象方法: 子类继承的事情,提高代码的复用性。
抽象类中可以定义构造方法,
抽象类中可以不定义抽象方法,意义:不让其他类创建本类的对象,交给子类完成。
abstract 不能和 stratic 关键字共存。
原因:类名.抽象方法的调用是没有意义,抽象方法没有方法体
abstract 不能和 final 关键字共存。
原因:被 abstract 修饰的方法会强制子类重写;被 final 修饰的方法是不让子类重写,所在他俩是矛盾的。
abstract 不能和 private 关键与共存。
原因:被 abstract 修饰的方法是为了子类看到并继承的; 被 private 修饰的不让子类访问,所以他俩是矛盾的。
接口 : 关键字 interface
接口不能被实例化,调用抽象方法没有意义;
可以按照多态的方式实例化 接口 接口名 = new 接口实现类();
接口的子类:可以是抽象类,意义不大。可以是具体类,要重写接口中的所有抽象方法。(推荐使用)
在接口中可以定义成员变量 int num =10 ; 但只能是常量并且是静态的公共的 , 没意义;
成员变量的默认修饰符: public static final (三个关键字没有顺序要求), 建议手动添加上。
接口没有构造方法;
接口中的方法:只能是抽象方法;默认是修饰符 public abstract;
类与类,类与接口,接口与接口的关系:单继承多实现。类与类是继承关系,只能是单继承,可以多层继承。 类与接口是实现关系,多实现,通过 , 隔开。接口与接口是继承关系,可以单继承,也可以多继承。
接口和抽象类的区别:1、成员区别 A 、抽象类成员方法,可以是变量,可以是常量。构造方法: 有成员方法: 可以是抽象方法,可以是普通方法;B、 接口:成员方法,只能是常量。构造方法: 没有成员方法: 只能是抽象方法; 2、关系区别: 类与 类是继承关系,类与接口是实现关系,接口与接口是单继承或多继承。3、设计理念区别: A、抽象类是 is-a 的关系 抽象类中定义是该继承体系的共性功能。是一个 继承关系B、接口是 like-a 的关系 接口中定义是该继承体系的扩展功能。 像一个 组合关系Day11Eclipse开发工具和API
MyEclipse开发快捷键:导包:Art + /;查看源码 : 选中类名 ( 按F3或者Ctrl+鼠标点击),上下移动:Art + 上下箭头;查找具体类:Ctrl + Ctrl + Shift + t ;Art+Shift + R : 选中一个后点击 Art+Shift + R 会把后面的同名也选中,比较方便查找具体方法:Ctrl + O;给建议:Ctrl+ 1 根据右边生成左边的数据类型,生成方法;删除代码:选中后Ctrl + d;抽取方法: Art + Shift + m;修改名字(类、方法)Art+Shift+ r 。自动生成有无参构造方法和set、get方法:Art + Shift + S;代码快速复制: Ctrl + Art + / ;
tostring() 方法:toString是Object类的方法,所有类都从Object类继承。如果你定义的类没有覆盖toString方法,则对象在调用toString方法时用的是Object类toString方法,返回的是“类名@hashcode". 当有非字符型数据要转换成字符串类型时,一个toString()方法即可将类型进行转换 如果StringBuffer想要输出的话,则必须用toString()方法先转换成String类型,才能输出因为它是Object里面已经有了的方法,而所有类都是继承Object,所以“所有对象都有这个方法”。
它通常只是为了方便输出,比如System.out.println(xx),括号里面的“xx”如果不是String类型的话,就自动调用xx的toString()方法
总而言之,它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法
写这个方法的用途就是为了方便操作,所以在文件操作里面可用可不用equals()方法和 == 的区别:共同点:都可以做比较,返回值都是 boolean 类型;区别:1、 == 是比较运算符,既可以比较基本数据类型,又可以比较引用数据类型,基本数据类型 是 比较的值, 引用数据类型是比较的地址值;2、 equals方法只能比较引用数据类型,equals()方法在没重写之前比较的是地址值,底层依 赖的是 == 号,但是比较地址值是没有意义的,我们需要重写equals方法比较对象中的属性值。
Day11常见对象:String类:字符串是常量(final修饰),一旦被赋值 就不能被改变。A:常见构造方法* public String():空构造* public String(byte[] bytes):把字节数组转成字符串* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串* public String(char[] value):把字符数组转成字符串* public String(char[] value,int index,int count):把字符数组的一部分转成字符串* public String(String original):把字符串常量值转成字符串public static void main(String[] args) {String s1 = new String();System.out.println(s1);byte[] arr1 = {97,98,99}; String s2 = new String(arr1); //解码,将计算机读的懂的转换成我们读的懂System.out.println(s2);byte[] arr2 = {97,98,99,100,101,102};String s3 = new String(arr2,2,3); //将arr2字节数组从2索引开始转换3个System.out.println(s3); 输出cde 从第二开始计算3个,包括第二个char[] arr3 = {'a','b','c','d','e'}; //将字符数组转换成字符串String s4 = new String(arr3);System.out.println(s4);String s5 = new String(arr3,1,3); //将arr3字符数组,从1索引开始转换3个System.out.println(s5);String s6 = new String("heima");System.out.println(s6);
* A:String类的判断功能* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写* boolean contains(String str):判断大字符串中是否包含小字符串* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾* boolean isEmpty():判断字符串是否为空。" "与null的区别:" "是字符串常量,同时也是一个String类的对象,既然是对象当然可以调用String类中的方法;null 是空常量,不能调用任何的方法,否则会出现空指针异常,null常量可以给任意的引用数据类型赋值。* A:String类的获取功能* int length():获取字符串的长度。* char charAt(int index):获取指定索引位置的字符* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索 引。* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。* lastIndexOf* String substring(int start):从指定位置开始截取字符串,默认到末尾。* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包含头,不包含尾,左闭右开迷惑题String类的转换功能: * byte[] getBytes():把字符串转换为字节数组。String a ="abc";byte[] arra = a.getBytes();for (int i = 0; i < arra.length; i++) {System.out.print (arra[i]+" ");//输出97 98 99 }* char[] toCharArray():把字符串转换为字符数组。String a ="heima";char[] a1 = a.toCharArray();for (int i = 0; i < a1.length; i++) {System.out.print (a1[i]+" "); //输出 h e i m a }* static String valueOf(char[] chs):把字符数组转成字符串。char[] arra = {'a','b','c'};String a1 = String.valueOf(arra);System.out.println(a1); //输出 abc* static String valueOf(int i):把int类型的数据转成字符串。String ints = String.valueOf(100);System.out.println(ints + 100); // 输出 100100* 注意:String类的valueOf方法可以把任意类型的数据转成字符串。 常见对象(String类的其他功能) String的去除字符串两端空格及案例演示 String trim()String s = " hei ma "; //String的去除字符串两端空格及案例演示 String trim()String s2 = s.trim();System.out.println(s2); //輸出 “hei ma”//倒叙输出字符串String arr = "abc"; //添加一个字符串char[] a1 =arr.toCharArray(); //将字符型转换成数组;String s = ""; //定义一个空字符串for(int i=a1.length-1;i >=0;i-- ){ //倒叙遍历数组s= s + a1[i]; }System.out.println(s); //输出 cba
统计大串中小串出现的次数Day12常见对象:
线程安全效率低,线程不安全效率高。
* B:StringBuffer和String的区别* String是一个不可变的字符序列* StringBuffer是一个可变的字符序列
StringBuffer线程安全的,效率低StringBuffer sb3 = new StringBuffer();System.out.println(sb3); // 输出 空值 System.out.println(sb3.toString()); //输出 空值 说明StringBuffer重写了toString方法。* A:StringBuffer的添加功能* public StringBuffer append(String str):* 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身验证 StringBuffer sb = new StringBuffer(); // 只new 创建一个对象StringBuffer sb2 = sb.append(true); //sb sb2 sb3 sb4 指向同一个内存地址StringBuffer sb3 = sb.append("heima");StringBuffer sb4 = sb.append(100); System.out.println(sb); //输出trueheima100System.out.println(sb2); //输出trueheima100System.out.println(sb3); //输出trueheima100System.out.println(sb4); //输出trueheima100//StringBuffer是字符串缓冲区,当new的时候在堆内创建一个对象,//底层是一个长度为16的字符数组,当调用添加的方法时,不会再重新创建对象,//在不断向原缓冲区添加字符。* public StringBuffer insert(int offset,String str):* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
StringBuffer 的insert方法 功能: 添加StringBuffer sb = new StringBuffer();sb.insert(3,"heima"); //插入数据 3 代表位置 heima 代表插入的数据。 因为0、1、2、的位置是空值//所以输出 字符串下标越界错误 输出 StringIndexOutOfBoundsExceptionSystem.out.println(sb); StringBuffer sb = new StringBuffer("1234");sb.insert(3,"heima"); System.out.println(sb);//输出 123heima4 在3的下标添加
StringBuffer 的deleteCharAt方法 功能:StringBuffer sb = new StringBuffer("1234");sb.deleteCharAt(5); System.out.println(sb); //报 越界异常 StringIndexOutOfBoundsExceptionsb.deleteCharAt(3);System.out.println(sb); // 输出123
StringBuffer 的delete方法 功能: 删除StringBuffer sb = new StringBuffer("heima"); sb.delete(0, 2);System.out.println(sb); //输出 ima 包含头,不包含尾清空缓冲区StringBuffer sb = new StringBuffer("heima"); sb.delete(0,sb.length()); //清空缓冲区 System.out.println(sb);
StringBuffer 的replace和reverse方法 功能: 替换和反转StringBuffer sb = new StringBuffer("heima");sb.replace(0, 3,"bai"); //包含头,不包含尾System.out.println(sb); //输出 baima sb.reverse(); //倒叙输出方法System.out.println(sb); //输出amieh
StringBuilder线程不安全,效率高 ,其方法与StringBuffer一样String 与 StringBuffer 和StringBuilder的区别:
String是一个不可变的字符序列;
StringBuffer 和StringBuilder是可变的字符序列StringBuffer 和StringBuilder 的区别:StringBuffer 是线程安全的,效率低;StringBuilder 是线程不安全的,效率高;Day13常见对象:
冒泡排序int[] arr = {50,80,30,10,100}; //声明一个数组for (int i = 0; i < arr.length - 1; i++) { //外循环是比较的循环次数for (int j = 0; j < arr.length -1 -i ; j++) { //内层循环控制每一趟排序多少次//减i是为了提高效率,减1是为了下标越界 内循环是把数组元素的作对比if(arr[j]> arr[j+1]){ //通过if判断前后数组元素的大小 把大值交换到前面int tem = arr[j];arr[j] = arr[j+1];arr[j+1] = tem;}}}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+ " ");}Arrays类的方法和概述:sort() 排序方法:int[] arr = {11,33,55,22,44,66,10};System.out.println(Arrays.toString(arr)); //输出 [11, 33, 55, 22, 44, 66, 10]Arrays.sort(arr); //排序方法System.out.println(Arrays.toString(arr)); //输出 [10, 11, 22, 33, 44, 55, 66]binarySearch() 方法 查找int[] a = {10,22,30,45,55,65,99};System.out.println(Arrays.binarySearch(a,99)); //输出6 按照下标位置输出
基本数据类型的包装类* C:基本类型和包装类的对应 byte Byteshort Shortint Integerlong Longfloat Floatdouble Doublechar Characterboolean BooleanInteger类System.out.println(Integer.toBinaryString(60)); // 转换二进制 输出 111100System.out.println(Integer.toOctalString(60)); // 转换八进制 输出 74 System.out.println(Integer.toHexString(60)); // 转换十六进制 输出 3cSystem.out.println(Integer.MAX_VALUE); //2的31次方-1 输出2147483647System.out.println(Integer.MIN_VALUE); //-2的31次方 输出-2147483648Integer的面试题:Integer a1 = new Integer(100);Integer a2 = new Integer(100);System.out.println(a1 == a2); //falseSystem.out.println(a1.equals(a2)); //true
//equals()方法//比较此对象与指定对象。当且仅当参数不为 null, 并且是一个与该对象包含相同 int 值的 Integer 对象时,结果为 trueInteger a3 = 128; //大于等于128就为falseInteger a4 = 128; //大于等于128就为falseSystem.out.println(a3 == a4); //falseSystem.out.println(a3.equals(a4)); //true //因为-128 到127 是byte的取值范围,如果在这个范围内取值 ,自动装箱就不会创建对象;//而是从常量池中取值,//如果超过了byte取值范围就会再创建新对象。Day14简单看了一遍:
在一个源文件中不能出现两个public 修饰的class类文件,可以有多个类,但不能用两个public修饰
system类
finalize()方法
当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。子类重写 finalize 方法,以配置系统资源或执行其他清除。
system.gc() 运行垃圾回收器会调用fianlize()方法去清理垃圾(相当于呼喊保洁阿姨清理垃圾)exit()方法 非0状态是异常退出,退出jvm
终止当前正在运行的 Java 虚拟机。参数用作状态码;根据惯例,非零的状态码表示异常终止currentTimeMillis()方法 获取当前系统时间
当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差(以毫秒为单位测量);long start = System.currentTimeMillis(); //开始时间for (int i = 0; i < 1000; i++) {System.out.println("*");}long end = System.currentTimeMillis(); //结束时间System.out.println(end - start);arraycopy()方法 数组拷贝;//从原数组中赋值一个数组,复制从指定的位置开始,到目标数组的指定位置结束。int[] src = {11,22,33,44,55};int[] dest =new int[8];for (int i = 0; i < dest.length; i++) {System.out.print(dest[i]+" "); //输出 0 0 0 0 0 0 0 0 } System.arraycopy(src, 0, dest, 0, src.length); //原数组 ,原数组起始位置,新数组,新数组起始位置,原数组长度。for (int i = 0; i < dest.length; i++) {System.out.print(dest[i]+" "); //输出 11 22 33 44 55 0 0 0}Date 类 的使用方法:Date d = new Date();// 不传入参数 代表 系统当前时间 使用 无参构造System.out.println(d); //输出系统当前时间Tue Jul 25 22:50:30 CST 2017Date d1 = new Date(0); // 传入任何参数输出一样 使用 有参构造 通过毫秒值创建时间对象System.out.println(d1);//输出 Thu Jan 01 08:00:00 CST 1970 系统默认规定的时间 , 08:00:00是北京东八区setTime()方法设置毫秒值Date d = new Date(); d.setTime(1000); //设置毫秒值 改变时间对象System.out.println(d); //输出: Thu Jan 01 08:00:01 CST 1970 输出 起始时间SimpleDateFormat 类的是用和讲述format() 方法:Date d = new Date(); //获取时间SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日 HH时:mm分:ss秒"); //创建日期格式化对象System.out.println(sd.format(d)); //将日期格式转换为字符串parse()方法//将字符串转换成日期格式.String str = "2010年10月10日 10:10:10"; //上下格式一定要完全相同,空格都不能相差。SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); Date d = sd.parse(str);System.out.println(d); 垃圾
Calendar 类add()方法、 set()方法Calendar c = Calendar.getInstance();c.add(Calendar.MONTH, 1); //可以添加年、月、日, c.add(年月日,添加数); c.set(Calendar.MONTH, 1); //可以设置年 、月、日 c.set(年月日, 设置数)System.out.println(c.get(Calendar.MONTH));
java入门基础一 1-14 之四类八种数据类型相关推荐
- JAVA的四类八种基本数据类型
先说明两个词汇的基本概念: bit (位):位是计算机中存储数据的最小单位,指二进制数中的一个位数,其值为"0"或"1". byte (字节):字节是计算机存储 ...
- java实现linkstring,【JAVA SE基础篇】32.String类入门
[JAVA SE基础篇]32.String类入门 1.字符串 1.String类又称作不可变字符序列 2.String位于java.lang包中,java程序默认导入java.lang包下所有的类 3 ...
- Java入门基础及面试100题--初入门
Java入门基础及面试100题 注:适合应届毕业生或java初入门者 1.面向对象的特征有哪些方面? 答:面向对象的特征主要有以下几个方面: - 抽象:抽象是将一类对象的共同特征总结出来构造类的过程, ...
- java入门基础学习(三)
文章目录 (一)有返回值的方法 (二)方法重载 习题 (一)有返回值的方法 格式:public static 返回值数据类型 方法名(参数){方法体return 数据;} 注意:1.返回值数据类型非v ...
- java入门基础教程(纯干货知识点+视频资源)
本套Java视频教程是黑马程序员冯老师精心录制的Java基础班视频,该视频专门针对零基础的学员录制,授课讲究通俗易懂.干货.通过该套Java视频教程的学习,相信你能够轻轻松松地入门java语言. 完整 ...
- java 数据类型转换的一场_Java基础 — 四类八种基本数据类型
整型:整数类型int 一般的数据. long 极大的数据. short 用于特定的场合,比如底层的文件处理或者需要控制占用存储单元空间量的大数组. byte 用于特定的场合,比如底层的文件处理或者需要 ...
- java入门基础重要知识必考考点
java入门基础重要知识 一. Java概述 二. Java语言基础 1. 标识符的命名规则: 2. 关键字 3. 基本数据类型(基本.引用) 4. 基本数据类型转换 5. 定义变量的语法: 6. 运 ...
- java入门基础(四)
文章目录 (一)对象和类 封装概述: (二)String对象 (三)StringBuilder对象 (四)集合ArrayList:可变的存储模型 练习 ArryayList练习 (一)对象和类 类:类 ...
- **JAVA入门基础2**(系列更新)———JAVA 基础变量
**JAVA入门基础2**(系列更新)---JAVA 基础变量 Java基础 1.注释 2.标识符和关键字 2.1 标识符 2.2 关键字(keyword) 3.数据类型 3.1 基本数据类型 3.2 ...
最新文章
- 华东理工大学计算机应用基础,最新华东理工大学计算机应用基础网上作业及全部答案...
- P1203 [USACO1.1]坏掉的项链Broken Necklace
- python变量区分大小写吗_Python变量名是不是区分大小写的
- Python:列表、集合等交集、并集、差集、非集简介及其代码实现之详细攻略
- exit()函数详解与Exit() 和 Return() 的区别
- 使用getGenericSuperclass()和getActualTypeArguments()将DAO做成泛型
- POJ 2886 Who Gets the Most Candies?
- VMware12安装虚拟机教程、Ubuntu16.04安装教程
- Java实现mysql的读写分离
- 一些利用开源浏览器核心开发专用浏览器的连接
- 计算机考试感受作文,关于考试后的感想作文(精选10篇)
- C语言生命游戏源代码
- 解决管家婆7在SQL2008上安装不了问题
- Consider defining a bean of type ‘com.xingchen.media.service.MediaFileService‘ in your configuration
- 华为电脑怎么录屏?分享你两个好方法
- 保持精力旺盛的25招 送给奋斗的男人 (转)
- 企业培训管理——学习平台应用功能
- 分享给你一份温暖,如冬日暖阳亦或是一杯午后的咖啡
- 长沙:胆大、心细、眼疾手快的“复苏先锋”
- 百度amp;高德地图小区景点边界轮廓实现