Javase
刘永盼
初始java
访问修饰符 类的关键字 类名 {
类体
}
在一个.java 文件当中，如果有类的访问修饰符为public 那么java规定类的类名必须与源文件同名
如果在一个java源文件当中可以定义为多个类，所以在编译阶段一个源文件中定义多少个类回产生多少个.class文件，且class文件与类名同名，所以我们有将.class文件称为类文件
在一个.java源文件当中只可以定义一个public访问修饰的类
Javac指令后面跟的是源文件
Java指令在查找.class文件时候会以系统环境中的classpath的变量去查找.class文件，若没有配置classpath，会在指令所在的位置进行查找
Jdk的配置与安装
Javac编译
Java执行
Jvm和jre 的关系
Jre
包含jvm,jvm是运行java程序的核心虚拟机，而运行java程序不仅需要虚拟机，而且需要其他类的加载器，字节码校验器，以及大量的类库，jre除了包含jvm之外，还包含了运行java程序的其他环境支持
Path环境变量：系统根据环境变量来查找字节码命令
数据类型
java当中数据类型的分类
1：基本数据类型
byte:一个字节型 —128——127
short:短整形，两个字节，-32768——32767
int:整形，四个字节
long:长整形，八个字节
float:单精度浮点型，占四个字节
double:双精度浮点型，8个字节
char:字符型，使用单引号包裹一个字符，占2个字节
*boolean:布尔型，取值为false,或者ture,占一个字节
2，引用数据类型：类，数组，接口，枚举，注释等
数值中可以使用下划线进行分隔，但是并未影响数值本身的值
列入： 123_23;可以等同与12323
public class datatype {
public static void main(String[] args) {
/**
* 声明变量语法
* 数据类型 变量名=值
*
* 局部变量的特点
* 1：局部变量必须先声明，然后赋值，才能使用
* 2；局部变量不能重名
* 3；局部变量遵循标识符规定
*
*/
//byte a =10;
// char c = 'a';
// boolean b1= false;
String s="hp" ;
System.out.println(s);
}
}
/**
*
* @author HP
*a-z,,97-122
*A-Z,,65_90
*0-9,,48_57
*/
public class Testchar {
public static void main(String[] args) {
//char类型在运算时可以自动提升为整型
char c= '女';
int i=c;
int j=97;
//int类型如果需要转化为char型，需要强制类型转化
char c1=(char)j;
System.out.println(i);
System.out.println(c1);
}
}
@author HP
*常量；在程序运行时候，不变的量称之为常量
*分为
*1：文字常量，在程序当中直接给出量值的常量
*2：符号常量，在程序当中使用final修饰的变量成为符号常量
*基本数据类型转换
*特点：
*1，可以从低精度转换为高精度
*2，如果需要将高精度转换为低精度需要强制类型转换
*/
public class Typechange {
public static void main(String[] args) {
int i=(int)12.9;//强制类型转化以后直接去掉小数点部分
System.out.println(i);
int m=20;
int n=10;
int temp=0;
temp=m;
m=n;
n=temp;
System.out.println(m+" "+n);
}
}
*
* 关系运算符 >, <, >= , <= ,== , !=
* 其结果是boolean
*/
/*
* 逻辑运算符
* &，逻辑与 两边都得运算
* |，逻辑或
* !，逻辑取反
* &&，短路逻辑与 ,,只要左边为假，就不计算右边的
* ||，短路逻辑或,,只要左边表达式为真，则不计算右边的表达式
* 其结果还是boolean
*/
/**
* 位运算符
* &，按位与
* |，按位或
* ^,按位异或
* ~，按位取反
* <<,左移
* >>,右移
* 运算时现将数字转化为二进制，其结果仍为十进制
*
*/
public class Testoperator4 {
public static void main(String[] args) {
int a=5&6;
System.out.println(a);
int b=5<<2;//向左移动i位，相当于给原数*2的i次方
System.out.println(b);
int c=5>>2;//向右移动i，相当于原数/2的几次方
System.out.println(c);
}
}
package datatype;
import java.util.Scanner;
public class Huiyuan {
public static void main(String[] args) {
System.out.println("请输入4位会员卡号:");
Scanner s1= new Scanner(System.in);
int i= s1.nextInt();
if(1000<=i&&i<=9999){
System.out.println("会员卡号是:"+i);
int a,b,c,d,num;
a=i/1000;
b=(i-1000*a)/100;
c=(i-1000*a-100*b)/10;
d=i-1000*a-100*b-10*c;
num=a+b+c+d;
System.out.println("千位数:"+a+" "+"百位数:"+b+" "+"十位数:"+c+" "+"个位数:"+d);
System.out.println("会员卡号"+i+"各位之和为"+num);
}
else{
System.out.println("输入的卡号错误");
}
}
}
流程控制
/*
* if选择结构
* 单分支
* if(表达式){
* }
* 双分支
* if(表达式){
* }
* else{
*
* }
* 多分支
* if（表达式）{
*
* }else if（表达式）{
*
* }else{
*
* }
*/
/*
* 循环结构
* for(初始条件;判断条件;步长){
* 循环体
* }
*
* while(表达式){
* 循环体
* }
*
* 循环次数确定的情况下，最好使用for循环
* 循环次数不确定的情况下，最好使用while循环
*
* do{
* 循环体
* }while(表达式);
*/
public class TestCircle01 {
public static void main(String[] args) {
for(int i=0;i<3;i++){
System.out.println("好好学习，天天向上");
}
int sum=0;
for(int i=1;i<=10;i++){
sum=sum+i;
}
System.out.println(sum);
int j=1;
int count=0;
while(j<=100){
count=count+j;
j++;
}
System.out.println(count);
int k=1;
int result=0;
do{
result=result+k;
k++;
}while(k<=100);
System.out.println(result);
for(int m=0,n=6;m<=6&&n>=0;m++,n--){
System.out.println(m+"+"+n+"="+(m+n));
}
Scanner input=new Scanner(System.in);
System.out.println("请输入学生姓名");
String name =input.next();
int value=0;
for(int i=1;i<=5;i++){
System.out.println("请输入第"+i+"门课的成绩");
int score =input.nextInt();
value=value+score;
}
int avg=value/5;
System.out.println(name+"的平均分是"+avg);
}
}
public class TestCircle2 {
public static void main(String[] args) {
Scanner input= new Scanner(System.in);
int sum=0,avg=0;
String str="";
do{
System.out.println("请输入学生姓名");
String name = input.next();
for(int i=1;i<=5;i++){
System.out.println("请输入5门功课当中第"+i+"门功课的成绩");
int score=input.nextInt();
sum=sum+score;
}
avg=sum/5;
System.out.println(name+"的平均分时"+avg);
System.out.println("是否继续输入(y/n");
str=input.next();
}while(str.equals("y"));
System.out.println("谢谢使用");
}
}
break的标签语法的使用,其作用就是退出标签所确定的循环结构
public class TestCircle4 {
public static void main(String[] args) {
//break,用于循环语句当中，退出当前循环
// for(int i=1;i<=10;i++){
// if(i%4==0){
// break; //跳出当前的for循环，后面不能出现任何语句
// }
// System.out.println(i);
//
// }
//
// //continue:跳过循环体当中的内容执行下一次循环
// //打印1到10非4的倍数
// for(int i=1;i<=10;i++){
// if(i%4==0){
// continue;
// }
// System.out.println(i);
// }
//判断一个数是否为素数(只能被1和它自身整除)，，，1除外
Scanner input =new Scanner(System.in);
System.out.println("请输入任意一个数");
int a = input.nextInt();
boolean b=true;
for(int i=2;i<a;i++){
if(a%i==0){
b=false;
break;
}
}
if(b==false){
System.out.println("不是素数");
}else{
System.out.println("是素数");
}
}
}
/*
*计算1-3+5-7+…-99+101的值
*/
public class Test06 {
public static void main(String[] args) {
int sum=0;
int t=-1;
for(int i=1;i<=101;i=i+2){
t=-t;
sum=sum+i*t;
}
System.out.println(sum);
}
}
数组
/*
* 数组存储若干同类型数据的集合，创建一个数组，其实就是在内存中开辟一个连续的空间，
* 最低地址对应数组的第一个元素，最高地址对应数组的最后一个元素
* 数组的要素:
* 1:数组名，通过数组名访问数组元素
* 2，数组元素，数组中存放的数据
* 3，数组下标，数组下标从0开始，到数组长度-1；
* 4，元素类型，数组中存放的数据的类型
* 使用数组；
*
* 注意事项；
* 1 数组需要先声明，初始化，然后才能使用
* 数组声明: 数据类型[] 数组名；
* 数组的初始化:
* 静态初始化:数组名=new 数据类型[]{值1，值2，值3，~值n}
* 动态初始化:数组名=new 数据类型[10];
*
* 静态初始化和动态初始化的区别
*静态初始化在初始化的时候没有指定数组 的长度，而是有元素个数决定其长度
*动态初始化在初始化的时候指定了数组的长度
*
*数组和声明合并
*数据类型[] 数组名= new 数组类型[]{值}
*数据类型[] 数组名 = new 数组类型[数组长度]
*2,数组本身也是一种类型，叫应用类型
*/
public class TestArray1 {
public static void main(String[] args) {
//静态初始化
int[] a1=new int[]{10,20,30};
//动态初始化
char[] c1=new char[10];
//对数组赋值:数组名[]下标=值
c1[0]='s';
c1[1]='a';
//动态初始化时系统对指定元素类型的数组进行初始化
//对于byte,short,long,int 元素类型的数组，默认值为0
//float,double,默认为0.0
//char默认为' ';
//boolean默认为false;
byte[] b1=new byte[5];
//获取数组元素；数组名[下标]
System.out.println(b1[0]);
System.out.println(c1[0]);
//获取数组长度:数组名.length;
System.out.println("数组长度"+b1.length);
//使用循环便利数组,查看
for(int i=0;i<a1.length;i++){
System.out.println(a1[i]);
}
}
}
/*
*
* 插入一个数值，其余数字往后移动
*/
public class Testwork02 {
public static void main(String[] args) {
int a[]=new int[6];
a[0]=15;
a[1]=45;
a[2]=35;
a[3]=32;
a[4]=18;
for(int i=a.length-1;i>1;i--){
a[i]=a[i-1];
}
a[2]=88;
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}
/*
* 删除数组元素
*/
public class Testwork3 {
public static void main(String[] args) {
int []a=new int[]{10,20,30,40,50}; //静态初始化
for(int i=2;i<a.length-1;i++){
a[i]=a[i+1];
}
a[4]=0;
for(int j=0;j<a.length;j++){
System.out.println(a[j]);
}
}
}
package com.testoop6;
/**
* 排序
* 1，冒泡排序
* 2，选择排序
* 3，快速排序
*
*冒泡排序:
*以从小到大为例，通过比较前后两个元素，如果前面的元素大于后面的元素，
*则交换位置，否则不交换，通过便利一趟序列，能够将最大的元素移动到最后的位置，
*最后通过N-1趟便利，将顺序有小到大排出
*
*选择排序:
*从带排序序列r[1],r[2],r[3],,,r[N]中选择一个最小值，将最小值和R[1]进行交换
*，然后再从R[2],R[3],,;,,R[N]选择一个最小值，和r[2]进行交换，依次类推，将
*最终序列由小到大排出
*
*
*/
public class Testsort01 {
public static void main(String[] args) {
int []a=new int[]{6,8,2,4,9,10,1};
int temp;
// for(int j=1;j<a.length;j++){ //外层循环控制躺数
// for(int i=0;i<a.length-j;i++){ //内存循环比较相邻元素
// if(a[i]>a[i+1]){
// temp=a[i];
// a[i]=a[i+1];
// a[i+1]=temp;
// }
// }
// }
// for(int i=0;i<a.length-1;i++){
// for(int j=i+1;j<a.length;j++){
// if(a[i]>a[j]){
// temp=a[j];
// a[j]=a[i];
// a[i]=temp;
// }
// }
// }
int flag=1;
for(int j=0;j<a.length-1;j++){
int min=a[j];
for(int i=j+1;i<a.length-1;i++){
if(a[j]>a[i]){
min=a[i];
flag=i;
}
}
if(min!=a[j]){
temp=a[j];
a[flag]=a[j];
a[flag]=temp;
}
}
for(int k=0;k<a.length;k++){
System.out.println(a[k]);
}
}
}
package com.testoop6;
/*
* 二分法查找：在已经排序好的基础上，选取数组的中间元素进行比较，如果相等，则查找成功
* 如果被查找的数字小于中间数字，则从中间数字左边部分重复上述操作，如果被查找的数字
* 大于中间数字则从右边继续重复上述操作
*/
public class Testsort02 {
public static void main(String[] args) {
int[] a=new int[]{4,5,13,13,13,14,15};
int target=13;//需求，返回11的下标
int i=0;
int j=a.length-1;
int mid;
while(i<=j){
mid=(i+j)/2;
if(a[mid]==target){
for(int k=mid;k<a.length;k++){ //查找后面重复的目标数字
if(a[k]==a[mid]){
System.out.println("查找成功,下标为："+k);
}else{
break;
}
}
break;
//continue;
}
if(target<a[mid]){
j=mid-1;
}
if(target>a[mid]){
i=mid+1;
}
}
}
}
// for(int k=mid-1;k>0;k--){ //查找前面的重复目标数字
// if(a[k]==a[mid]){
// System.out.println("查找成功,下标为："+k);
// }else{
// break;
// }
// }
package com.testoop7;
/**
* 多维数组
* @author HP
*一个制表符占八个空格
*/
public class MultiArray01 {
public static void main(String[] args) {
//二维数组声明以及初始化
int [][]b=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//二维数组的声明以及初始化
//int [][]b=new int[3][];
//b[0]=new int[]{1,2,3};
//访问数组元素
//获取高维数组长度
//System.out.println(b.length);
//获取高维数组下标为0的数组的长度
//System.out.println(b[0].length);
//遍历数组
for(int i=0;i<b.length;i++){
for(int j=0;j<b[i].length;j++){
System.out.print(b[i][j]+"\t");
}
System.out.println();
}
}
}
package com.testoop7;
public class MultiArray02 {
public static void main(String[] args) {
int[] a=new int[]{4,5,6,8,9,10,10,10,11,12,13,14,15};
int target=10;//需求，返回11的下标
int i=0;
int j=a.length-1;
int mid;
while(i<=j){
mid=(i+j)/2;
if(a[mid]==target){
for(int k=mid-1;k>0;k--){ //查找前面的重复目标数字
if(a[k]==a[mid]){
System.out.println("查找成功,下标为："+k);
}else{
break;
}
}
for(int k=mid;k<a.length;k++){ //查找后面重复的目标数字
if(a[k]==a[mid]){
System.out.println("查找成功,下标为："+k);
}else{
break;
}
}
break;
//continue;
}
if(target<a[mid]){
j=mid-1;
}
if(target>a[mid]){
i=mid+1;
}
}
}
}
/*
*求二维数组中的最大值及其对应的下标
*/
public class Test07 {
public static void main(String[] args) {
int [][]a=new int[][]{{20,12,1},{15,20,10},{30,6,10}};
int flag1=0,flag2=0;
int max=a[0][0];
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
if(max<a[i][j]){
max=a[i][j];
flag1=i;
flag2=j+1;
}
}
}
System.out.println("二维数组的最大值为"+max);
System.out.println("对应的坐标为"+flag1+"和"+flag2);
}
}
Java8增强的工具类: Arrays
Java提供的Arrays包含了一些static修饰的方法可以直接操作数组
Int binarySearch（type[]a,type key）使用二分法查找数值a在数组中出现的索引
Void sort（type[]a）对数组进行从小到大进行排序
String toString（type[]a）,该方法将一个数组转换成一个字符串，该方法按顺序把多个数组元素连接在一起，多个数组元素使用英文逗号和空格隔开
类和对象
package com.oop1;
/*
* 实例变量和静态变量的区别
* 实例变量是在创建对象的时候分配内存并且初始化
* 静态变量是在类加载的时候分配内存并且初始化，和是否创建对象无关
*
*/
public class Computer {
String brand="三星";
int size=14;
/*
* static修饰的变量:在类被装载到虚拟机后，就会将类中的静态变量在
* 方法区分配一块内存,该内存被所有对象共享，程序结束后，由系统自动释放
*/
static String color;
public static void main(String[] args) {
Computer c=new Computer();
// System.out.println(c.brand);
// System.out.println(c.size);
System.out.println(Computer.color);
System.out.println(c);
}
}
package com.oop1;
/*
* 类:是具有相同或者相似性质对象的抽象
*
* 对象:是类的具体化，或者类的实例化被称之为对象
*
* 对象的属性
* 变量：
* 局部变量：类体中，方法内的变量
* 成员变量：类体中，方法外的变量，，，，其又分为
* 实例变量和类变量（静态变量）
* 实例变量:属于具体的某个对象,通过创建对象后才可以访问
* 访问方式:对象名.实例变量
* 类变量:属于类的本身，被所有对象共享,并且需要static关键字修饰
* 访问方式:类名.静态变量名
*
*
* 虚拟机将内存划分为5个区域
* 1:栈内存，属于一种先进后出的数据结构，其存储效率高，由程序（编译器）在
* 内存中主动分配内存和释放内存，主要用来存储局部变量，对象的引用，方法的参数
* 2:堆内存，属于一种树形（非连续的数据结构）。需要在程序运行期间通过new关键
* 字分配内存，主要用来存储类的实例变量，实例方法的入口等信息，在java中，
* 无需程序员主动释放内存，而是由java虚拟机中的GC（垃圾回收器）主动释放
* 3:方法区（静态区），主要用来存储类的结构信息，静态变量，成员方法，常量等信息
* 4:本地方法栈，主要用来存储非java语言编程的程序的入口（程序的指定地址）
* 5:程序计数器，主要用来存储每一个线程的指令地址
*
*
* 成员方法分为实例方法和静态方法
*
* 实例方法:属于具体某个对象，通过对象名.方法名（）的方式访问
*
* 静态方法:属于类，需要通过static关键字修饰，通过类名.方法名()的方式访问
*
* 基本和引用类型
*/
public class Student {
//实例变量
String name;
int age;
//实例方法
public void fun1(){
System.out.println("无返返回值的实例方法");
}
public int fun2(){
return 1; //return 用来结束方法的执行并且返回一个常量值或者一个变量值
} //并且一个方法只能执行一条return语句
public String fun3(){
return " ";
}
public String fun4(int i){ //i为形参
System.out.println(i);
return " ";
}
public static void main(String[] args) {
/*
* 实名对象的创建,其语法为
* 类名 对象名=new 类名();
*/
//创建对象,每个对象的属性自己私有
Student stu=new Student();//stu装的是Student的地址
stu.age=23;
stu.name="张三";
System.out.println(stu.name);
stu.fun1();
int result=stu.fun2();
System.out.println(result);
stu.fun4(4); //为实参
Student stu1=new Student();
System.out.println("应用类型使用==比较地址"+(stu==stu1));
//匿名对象的创建，其无法输出
new Student().name="时尚生活";
}
}
package com.oop2;
/*
* 静态方法
* 调用，通过类名访问静态方法
*
* 什么时候定义静态方法，什么时候定义实例方法？
* 如果一个类中的方法需要经常被其他类访问(制作工具类---开发过程中，经常使用的)，
* 此时该类中的方法定义为静态方法方便使用，否则定义为实例方法
*
*/
public class Phone {
public static void p1(){ //没有返回值的静态方法
System.out.println("没有返回值的静态方法");
}
public static void main(String[] args) {
Phone.p1();
}
}
package com.oop2;
/**
* 方法的重载:在同一个类中，方法名相同，参数类型或者参数个数不同，与返回值无关的 方法
* 具体调用哪一个，住要是由重载方法的类型和个数来确定
*
*/
public class TestOverLoadMethod {
public int fun(){
return 1;
}
public void fun(int i){
}
public void fun(String i){
}
public void fun(String i,int j){
}
public static void main(String[] args) {
char[] c=new char[]{'a','b'};
System.out.println(c);
}
}
package com.oop3;
构造器
系统一般会默认分配，如若用户自己定义，系统则就不在自动加上，运行时候，是由系统自动调用，而非程序员调用，其也重载，
构造方法的作用 : 通常是用来初始化操作
public class Book {
//成员变量的定义
String name;
String author;
int totalPage;
//通过构造器来改变初值
public Book(String name,String author,int totalPage){
this.name=name;
this.author=author;
this.totalPage=totalPage;
}
public static void main(String[] args) {
//定义两个对象
Book b1=new Book("西游记","吴承恩",500);
Book b2=new Book("红楼梦","曹雪芹",800);
//定义两个数组
Book[] book=new Book[3];
//将数组指向对象
book[0]=b1;
book[1]=b2;
//通过for-each结构遍历数组
for(Book b:book){
if(b!=null){
System.out.println("书名为:"+b.name+"作者为:"+b.author+"页数为:"+b.totalPage);
}
}
}
}
package com.oop3;
/*
* this代表当前类的一个隐藏对象，他会在运行期间指向调用方法的对象
*
* this
* 1:出现在实例方法中，代表了当前正在调用的对象
* 2:可以解决成员变量和局部变量重名的问题
* 3:this可以用来调用当前类中的构造方法,并且只能出现在第一行
*
* this的注意事项
* this关键字不能出现在静态方法里面;
*
* 静态方法里面访问成员变量的注意事项
* 1：静态方法中不能出现this
* 2：静态方法中如果需要访问实例变量或者实例方法，需要进行实例化才可以访问
* 3：静态方法中可以直接访问静态变量(默认缺省类名点.)和静态方法
*
* 构造方法的作用:通常用来初始化操作
*/
public class Demo1 {
public static void main(String[] args) {
Demo1 d = new Demo1();
System.out.println(d);
d = new Demo1();
System.out.println(d);
}
}
package com.oop3;
/*
* 构造方法的特点
* 1 在实例化对象的同时，由系统自动调用的方法
* 2 构造方法的方法名一定要和类名相同
* 3 构造方法可以带参数，可以重载
*/
public class Demo2 {
public Demo2(){
System.out.println("无参");
}
public Demo2(int i){
System.out.println("有参");
}
public static void main(String[] args) {
Demo2 d = new Demo2();
}
}
package com.oop4;
/*
* java中的访问权限，主要通过以下几个关键字来实现
* 1:private 私有的 可用来修改成员变量，成员方法，构造方法，内部类，属于最严格的访问权限
* 使用private修饰的成员，只能在当前类当中访问
* 2:default,默认的访问权限，只能在同一个包地下相互访问，子类中不可以访问
*
* 3.protected:受保护的访问权限,只能在同一个包，同一个类，子类中访问
*
* 4.public 公共的访问权限，可以在任何类，任何包地下访问
*/
| 作用域修饰符 | 同一个类中 | 同一个包中 | 子类中 | 任何地方 |
| private | 可以 | 不可以 | 不可以 | 不可以 |
| 默认修饰符 | 可以 | 可以 | 不可以 | 不可以 |
| protected | 可以 | 可以 | 可以 | 不可以 |
| public | 可以 | 可以 | 可以 | 可以 |
包装类
/*
* 枚举类
* 枚举：通常用来定义一组相同的常量
*/
public enum Season {
spring("春天"),fall("秋天"),winter("冬天"); // 第一行必须写一些常量
String name="";
private Season(String name){ //构造方法必须私有
this.name = name;
}
public String getname(){
return name;
}
}
package com.useful;
import java.util.Arrays;
public class Testarray {
public static void main(String[] args) {
int []a =new int []{10,20,30};
int []b =new int[3];
System.arraycopy(a,0,b,0,a.length);
Arrays.sort(a);
for( int i=0;i<b.length;i++){
System.out.println(b[i]);
}
Student[] stu = new Student[2];
Student s1= new Student();
s1.age=30;
Student s2= new Student();
s2.age=40;
System.exit(2);//终止当前程序的运行
System.gc(); //垃圾回收机制（准备操作，无法立即执行）
}
}
package com.useful;
import java.io.IOException;
import java.util.Date;
/*
* date : 日期类
*/
public class TestDate {
// //获取年份
// int year=date.getYear()+1900;
// System.out.println(year);
// //获取月份
// int month=date.getMonth()+1;
// System.out.println(month);
public static void main(String[] args) throws IOException {
while(true){
Date d = new Date();
String s = d.getHours()+":"+d.getMinutes()+":"+d.getSeconds();
System.out.println("当前时间为："+s);
if(s.equals("23:38:40")){
Runtime r = Runtime.getRuntime();
r.exec("H:\\360Downloads\\Tencent\\QQ\\Bin\\QQScLauncher.exe");
break;
}
}
}
}
package com.useful;
import java.io.IOException;
/*
* java 的运行机制，在java虚拟机运行期间执行的功能
*/
public class TestRuntime {
public static void main(String[] args) throws IOException {
Runtime r= Runtime.getRuntime();
System.out.println(r.totalMemory());
//用于打开其他应用
r.exec("H:\\360Downloads\\Tencent\\QQ\\Bin\\QQScLauncher.exe");
}
}
package com.useful;
import java.util.Arrays;
/*
* 对象数组排序
*
*
* System.exit(0);//退出Java虚拟机
*/
public class TestSystem {
public static void main(String[] args) {
//创建两个学生对象
Student s1=new Student();
s1.age=25;
Student s2=new Student();
s2.age=30;
//定义两个对象数组
Student[] s=new Student[2];
s[0]=s1;
s[1]=s2;
TestArrays.testsort(s); //调用方法对数组排序
//操作数组的实用类
//Arrays.sort(s); //直接调用方法进行排序
for(Student stu:s){
System.out.println(stu.age);
}
}
}
package com.useful1;
/*
*
* Integer:
* 1:实现和基本类型的相互转换
* 2：封装了基本类型的相关属性，和其他对象的转换方法
*
*/
public class TestInteger {
public void fun(int i){
}
public void fun1(String s){
}
public static void main(String[] args) {
TestInteger t = new TestInteger();
//自动装箱：将基本类型转化为对象类型的过程
int i=1;
Integer it =i;
//自动拆箱：将对象类型转化为基本类型的过程
Integer d = 20;
int h = d;
String s = "200";
//将字符串转化为int类型
Integer.parseInt(s);
t.fun(Integer.parseInt(s));
//将int转化为字符串
int r =100;
Integer.toString(r);
t.fun1(Integer.toString(r));
}
}
package com.useful1;
import java.util.Random;
/*
* 数学类
*/
public class TestMath {
public static void main(String[] args) {
//绝对值
// int abs=Math.abs(-1);
// //最大值
// int max=Math.max(10, 20);
// double d=Math.random(); //大于0小于1的数
// //从0到100返回6个随机数
// for(int i=1;i<=6;i++){
// int a = (int)(Math.random()*100);
// System.out.println(a);
//
// 产生1到10中6个不相同的随机数
int[] a=new int[6];
a[0]=20;
for(int i=0;i<a.length;i++){
int as = (int)(Math.random()*10);
for(int j=0;j<=i;j++){
if(as!=a[j]){
if(j==i){
a[i]=as;
break;
}
}
else{
}
}
}
for(int j=0;j<a.length;j++){
System.out.println(a[j]);
}
}
}
package com.useful1;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* 实用类测试日期
*
*/
public class TestSimpleDateFormat {
public static void main(String[] args) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String date=format.format(new Date()); //将日期转换为字符串
System.out.println(date);
//将字符串转换为日期 调用的是format.parse()方法
String s = "2017-07-28 09:41:12";
try {
Date d =format.parse(s);
System.out.println(d);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
package com.testSet;
import java.util.Date;
public class Emp {
private String id;
private String name;
private int age;
private Date date;
public Emp(String id,String name,int age,Date date){
this.id=id;
this.name=name;
this.age=age;
this.date=date;
}
public String toString(){
return "编号为"+id+"姓名为"+name+"年龄为"+age+"入职日期为"+new Date();
}
}
package com.testSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
Emp e1 = new Emp("1000","张三",20,new Date());
Emp e2 = new Emp("1002","李四",202,new Date());
Emp e3 = new Emp("1003","王五",205,new Date());
List list = new ArrayList();
list.add(e1);
list.add(e2);
list.add(e3);
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
字符串的操作：
/*
* String :不可变的字符串
* 字符串的用法
*/
public class TestString {
@Test
public void testCharAt(){
String s = "acbd";
char c = s.charAt(2);
System.out.println(c);
String user = "ab12男女cd";
int count=0;
for(int i=0;i<user.length();i++){
if(user.charAt(i)>='0'&&user.charAt(i)<='9'){
count++;
}
}
System.out.println(count);
}
//提取字字符串
@Test
public void testSubString(){
String s = "abcdefghijk";
String s1=s.substring(0, s.length());
System.out.println(s1);
}
//比较字符串的内容
@Test
public void testequals(){
String s1 = "abcd";
String s2= "abcd";
if(s1.equals(s2)){
System.out.println("相等");
}
}
//判断母串中是否包含指定的子串
@Test
public void testContains(){
String s = "abcdef";
String s1= "cde";
boolean b =s.contains(s1);
System.out.println(b);
}
//查找子串的手字符在原来字符串中第一次出现的位置，存在则返回索引，不存在则返回-1
@Test
public void testIndexof(){
String s = "abcdefgh";
String s1 = "bcd";
int i = s.indexOf(s1);
System.out.println(i);
}
@Test //拆分字符串
public void testSplit(){
String s = "西安.jpg";
String[] value=s.split("\\."); //注意是两个\\
if(value[value.length-1].equals("jpg")){
System.out.println("正确");
}
else{
System.out.println("错误");
}
}
//替换字符串
@Test
public void testreplace(){
String s = "西安邮电“大学";
String d = s.replace("邮电", "石油").replaceAll("“", "\"");
System.out.println(s); //原字符串仍旧不变
System.out.println(d);
}
//转换大小写
@Test
public void testUpperOrLower(){
String s = "abcdef";
String s1 = s.toUpperCase();
System.out.println(s1);
}
}
import org.junit.Test;
/*
* StringBuffer:一个可变的线程安全字符串
* StringBuilder:代表一个可变的线程不安全字符串
* 赋值必须得通过创建对象类进行赋值
* 常用方法如下
* 1:append():将指定的字符串追加到原字符串的末尾
* 2：insert():在指定赋的位置插入字符（串）
* 3：delete():删除指定位置或者某个区间内的字符串
*/
public class TestStringBuffer {
//追加字符串
@Test
public void add(){
StringBuffer s = new StringBuffer("abc");
//追加
s.append("def");
s.append("gh");
System.out.println(s);
}
//指定位置插入字符串
@Test
public void testinsert(){
StringBuffer s = new StringBuffer("abc");
s.insert(1, "er");
System.out.println(s);
}
//删除
@Test
public void testdelete(){
StringBuffer s = new StringBuffer("abcefg");
s.delete(1, 3); //不含有3
System.out.println(s);
}
}
泛型
package testtype;
import java.util.List;
/*
* ? : java泛型通配符
* 一旦某个类和接口使用通配符后，该泛型类或者泛型接口可以看成该类的任意泛型类或者泛型接口父类型
*/
public class TestA {
public void fun(List<?> list){
}
//与fun相同
public void fun2(List<? extends Object> list){
}
//设置通配符上限，规定了通配符只能是A类或者其他子类类型
public void fun3(List<? extends A> list){
}
//设置统配符的下限:规定了通配符只能是A类或者其他父类类型
public void fun4(List<? super A> list){
}
}
package testtype;
/*
* 泛型:也叫参数化类型，jdk1.5以后引入，允许程序在定义类，接口，方法时加入类型形参，在声明变量，创建
* 对象时动态的指定该类型实参，给定义的泛型称之为泛型类，给接口定义的泛型被称之为泛型接口
* 泛型的作用：通过给类，接口加入泛型后，可以在编译期间进行类型检查，避免程序在运行期间出现类型转换错误
*
*/
public class testtype<T> { //T必须是引用类型
T t;//使用泛型声明
String s ="sdc";
public static void main(String[] args) {
testtype<String> tt = new testtype<String>();
}
}
异常
异常学习总结
异常：异常是程序中有可能产生的错误，一旦错误产生，Java语言要么在底层使用事先定义
好的异常对象进行处理，要么由我们程序员对代码进行处理
异常的分类：Java中定义了很多异常类，每一种异常都对应一个异常类，最顶层的异常父类是Throwable，其子类是error和exception，error是底层错误，程序员无法通过代码修正，而exception可以进行处理，其次exception异常可以划分为RuntimeException和非RuntimeException
（Checked异常）
Java中处理异常的方式：try catch finally throws throw
try catch finally：组合使用，用来捕获异常
try语句块的作用：放的是有可能产生异常的代码
注意事项：1：try中声明的变量的作用范围仅限于try块
2：当try中的某一行代码发生异常时，Java虚拟机会
负责产生一个异常对象，然后去找代码中的catch
进行匹配处理，此时，异常代码后面的代码将不再
执行
3：try语句块不能独立存在
catch语句块的作用：用来捕获Java虚拟机抛出的异常对象，然后进行
处理
注意事项：1：catch中定义的异常对象可以和Java虚拟机抛出的异常
对象类型一致或者是其父类
2：catch一旦捕获到具体的异常对象则进行处理，此时，
try catch正常执行完成，其后的代码（指的是try catch
后面的代码）会仍然执行，如果catch捕获不到，程序发生
例外并退出，不再执行try catch后的代码
3：一段代码可能会产生不同的异常类型，所以需要在try
后面跟上多个catch语句块，一旦try中产生异常，程序将
按照catch定义的顺序从上往下进行匹配，匹配成功，只
执行其中一条catch，其余catch将被忽略
4：养成在catch中处理异常的习惯，哪怕是输出一句话，
不能什么都不做
5：catch不能独立存在，变量作用范围仅限于catch块
finally语句块的作用：不论代码是否产生异常，其代码块中的代码
总是会被执行，除非在catch中加System.exit(0)；常用来关闭物理
资源（例如 关闭程序打开的文件）
java中的try catch是否会造成程序的中断？
不一定，如果try中的异常类型和catch匹配成功，则try catch正常完成，可以执行后面的代码
如果不能匹配，则程序发生例外退出
Java程序中什么时候需要显示的去捕获异常？
使用throws声明的非RuntimeException异常类或者其子类的异常需要
显示捕获，而只有RuntimeException或者其子类的异常是不需要显示
捕获的
throws：一般用于给方法声明异常，其次使用throws给方法声明的异常
，方法本身不做处理，而是交给调用者处理
throw: 抛出异常异常对象，通常用来自定义异常
为什么要自定义异常？
当jdk提供的异常不能满足实际开发需求时，需要自定义异常
步骤1：创建自定义异常类继承Exception，然后编写构造方法定义
异常信息字符串
步骤2：在类中使用异常，即使用throw抛出实例化的自定义异常对象
步骤3：在程序中捕获异常
流
package com.file;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
/*
* File : java提供了与平台无关的操作文件或者目录的工具类
* 无法访问文件内容
*/
public class TestFile {
//创建目录
@Test
public void TestcreateDir(){
File file = new File("f:/西安/音乐");
file.mkdirs();
}
//获取文件名和大小
@Test
public void test(){
File file = new File("F:/java");
System.out.println("文件"+file.getName()+"大小"+file.length());
file.delete();
}
//访问某个目录的子目录及其文件
@Test
public void fun1(){
File file = new File("D");
String[] s = file.list();
for(String s1:s){
System.out.println(s1);
}
}
public static void main(String[] args) {
File file = new File("c:/西安.txt");
try {
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
package com.IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/*
* java中流的分类
* 按照方向划分为：输入流和输出流
*
* 按照对文件的处理单元划分为：字节流和节点流
*
* 按照功能角色划分：节点流和处理流
* 节点流：可以直接嫁接在某个物理文件上
* 处理流：（也叫装饰流）不可以直接嫁接在某个物理文件上，但是可以直接嫁接在节点流上
*
* java流的四个顶层抽象类
* 1：InputStream:字节输入流(以字节为单位从文件中读取数据)
* 2：OutputStream:字节输出流(以字节为单位向目标文件中写入数据)
* 3：Reader:字符输入流(以字符为单位从原文件中读取数据)
* 4：Writer：字符输出流(以字符为单位向目标文件中写入数据)
*
*/
public class TestIO {
public static void main(String[] args) {
InputStream is =null;
try {
is = new FileInputStream("F:/文件.txt");
byte[] b = new byte[10];
int len=0; //保存读取到的实际字节数
while((len=is.read(b))!=-1){
for(int i=0;i<len;i++){
System.out.print((char)b[i]);
}
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try { //关闭文件
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
集合
package com.testlist;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import java.util.Vector;
import org.junit.Test;
/*
* List为一接口
*List集合：可以存放数量不等，类型不一的元素，类型不一的元素
*特点：
*元素有序，并且允许有null值和重复值
*
*List接口有一下的常用的实现类
*1：ArrayList(),底层实现为数组，适用于遍历查询，但是ArrayList是线程不安全的
*常用方法：
*初始容量为10，增长幅度为1.5倍
*add() 添加元素
*2:LinkedList():底层实现为双向链表，适合数据的增删改,也是线程不安全的
*3：Vector 底层实现也是数组，同样适用于遍历查询，但是Vector是线程安全的，并允许
*用户自动以初始容量和增长长度
*4 Stack:底层实现是栈，是一种先进后出的数据结构
*/
public class TestList {
@Test
public void TestStack(){
Stack s = new Stack();
//将元素入栈
s.push("abc");
s.push("efg");
while(!s.isEmpty()){ //用来判断栈低元素是否为空
System.out.println(s.pop());
}
}
public void TestVector(){
Vector v = new Vector(10,20);
v.add("战斗感");
v.add("战斗机");
for(Object obj : v){
System.out.println(obj);
}
}
@Test
public void TestLinkedList(){
LinkedList list = new LinkedList();
list.add("张三");
}
public static void main(String[] args) {
List list = new ArrayList();
//添加元素
list.add(10);
list.add("张丹");
list.add('男');
list.add(new Date());
//将下标为1的元素替换为李四
list.set(1, "李四");
//将下标为3的元素移除
list.remove(3);
//判断集合里面是否包含指定的元素
list.contains("李四");
//遍历集合
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//必须是Object类型
for(Object obj:list){
System.out.println(obj);
}
//随机生成6个不同的正数放入list的集合
for(int i=0;i<6;i++){
int a = (int)(Math.random()*10);
if(!list.contains(a)){
list.add(a);
}else{
i--;
}
}
for(Object obj:list){
System.out.println(obj);
}
//使用Iterator遍历数组,可以遍历任何集合,迭代器
Iterator it = list.iterator();
while(it.hasNext()){
Object obj= it.next();
System.out.println(obj);
}
}
}
package com.testMap;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;
/*
* Map 一种以键值对存储数据的集合，通过key可以找到唯一对应的value,其中k不允许重复，
* value可以允许重复
*
* 常用的实现类
* HashMap:线程不安全，可以使用null作为key或者value
* Hashtable:线程安全，不允许使用null作为key或者vakue，如果把null作为Hasgtable中，
* 将引发空指针异常
*/
public class Testmap {
public static void main(String[] args) {
Map<String,String> map = new Hashtable<String,String>();
map.put("name","张三");
map.put("age", "23");
map.put("add", "北京");
Set<String> set = map.keySet();
for(Object obj : set){
System.out.println(obj+" "+map.get(obj));
}
Map<String,String> map1 = new Hashtable<String,String>();
Map<String,String> map2 = new Hashtable<String,String>();
Map<String,String> map3 = new Hashtable<String,String>();
map1.put("姓名","23");
map1.put("地址 ","西安");
map1.put("年龄","56");
map2.put("姓名", "李四");
map2.put("年龄","32");
map2.put("地址", "北京");
map3.put("姓名", "王五");
map3.put("年龄","30");
map3.put("地址", "南京");
List<Map<String,String>> list = new ArrayList<Map<String,String>>();
list.add(map1);
list.add(map2);
list.add(map3);
for(int i=0;i<list.size();i++){
Map<String,String> m= (Map<String, String>)list.get(i);
Set<String> s = m.keySet();
for(String o :s){
System.out.println(o+" : "+m.get(o));
}
}
}
}
package com.testSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/*
* set:不允许有重复值，且无序的集合，
*
* set为一个借口，其HashSet为一个实现类
* 接口不能够实例化，创建接口对象的时候，只能够引用接口，指向它的实现类
* 常用的实现类
* list同样如此，接口均不能被实例化，都只能指向它的实现类
*
* HashSet
*
* 1:不能够保证元素的排列顺序，顺序可能与添加顺序不同
* 2:线程不安全，加入有两个或者两个以上的线程同时修改访了HashSet集合，输出结果就存在二义性
* 3:集合元素可以是null值
* 4:值不能重复
*
SotedSet：set的子接口，允许对元素进行排序的集合
常用的实现类:TreeSet 内部对数组自然排序
*/
public class TestSet {
public void testTreeSet(){
TreeSet ts = new TreeSet();
ts.add(6);
ts.add(5);
ts.add(10);
for(Object obj:ts){
System.out.println(obj);
}
}
public static void main(String[] args) {
Set set = new HashSet();
set.add("张三");
set.add("张三");
set.add("张三");
set.add("李四");
//遍历数组
Iterator it =set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
package com.testCollections;
/*
* Collection与Collections的区别
* Collection java中集合的父接口
* Collections 是操作集合的工具类，例如对集合进行排序，反转等，还可以将集合转换为线程安全等
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Collection与Collections的区别：
* Collection: 是Java中集合的父接口
* Collections： 是操作集合的工具类，例如可以对集合进行排序，反转等， 还可以将集合 转换为线程安全
*
*/
public class TestCollections {
public static void main(String[] args) {
//将list转换为线程安全的
List list=Collections.synchronizedList(new ArrayList());
list.add(5);
list.add(4);
list.add(7);
//Collections.sort(list);
//作业：自定义sort方法，对list排序
SortList.sort(list);
for(Object o:list){
System.out.println(o);
}
}
}
package com.testCollections;
import java.util.List;
public class SortList {
public static void sort(List list){
Object[] obj=list.toArray();
Object temp=null;
for(int i=0;i<obj.length;i++){
for(int j=0;j<obj.length-i-1;j++){
if((Integer)obj[j]>(Integer)obj[j+1]){
temp=obj[j];
obj[j]=obj[j+1];
obj[j+1]=temp;
}
}
}
for(int i=0;i<list.size();i++){
list.set(i, obj[i]);
}
}
}
类和对象笔记
1：类的概念
具有相同或者相似性质的对象的抽象
2：对象的概念
类的具体化
3: 如何创建对象?
类名 对象=new类名（）
4: 变量的划分？
变量分为成员变量和局部变量
局部变量就是类体中，方法内的变量
成员变量是类体中，方法外的变量，又分为实例变量或者静态变量（由成为类变量）
5 实例变量与静态变量？
实例变量就是类体中，方法之外的变量，但是没有关键字static修饰，引用的时候，必须通过创建一个对象来进行访问
而静态变量也是在类体中，方法之外的成员变量，但是有关键字static修饰，引用的时候是通过类名来进行访问的
6：实例方法与静态方法?
实例方法就是没有关键字static修饰，而静态方法就是需要static修饰
静态方法里面访问成员变量的注意事项
* 1：静态方法中不能出现this
* 2：静态方法中如果需要访问实例变量或者实例方法，需要进行实例化才可以访问
* 3：静态方法中可以直接访问静态变量(默认缺省类名点.)和静态方法
7：方法的传参?
基本类型在方法传参时传递值，，，，，为一个具体的值
引用类型在方法传参时传递地址
8: 方法的重载
方法的重载就是相同的方法名，但是参数类型和参数个数不同的方法，与返回值类型，修饰符等无关具体调用哪一个，有参数类型以及他的个数来确定，，，，不能使用方法的返回值类型作为区分方法重载的依据
9:this关键字
代表当前类的一个隐藏对象，会在运行期间指向调用该方法的对象
一般两种情形：
构造器中引用该构造器正在初始化的对象
在方法中引用调用该方法的对象
This可以代表任何对象，当this出现在某个方法时，它所代表的对象数不确定的，但是他的类型是确定的，他所代表的只能是当前类的实例，只有当这个方法调用时，他所代表的对象才能被确定下来，谁在调用这个方法，this就指谁
如果出现在实例当中，代表当前正在调用的对象
可以解决成员变量和局部变量重名的问题
This可以用来调用当前类中的构造方法
并且只能出现在第一行
注意：this不能够出现在静态方法之中，因为静态方法属于类，而this代表的是当前类的一个隐藏对象，是对象
10:构造方法
又被称之为构造器，系统一般会默认分配，如若用户自己定义，系统则就不在自动加上，运行时候，是由系统自动调用，而非程序员调用，其也重载，
构造方法的作用 : 通常是用来初始化操作
11:对象数组
里面只能够存放变量，不能够存放方法
12；面向对象的三大特征
1>:封装，将对象的状态信息隐藏在对象内部，不允许外部程序直接访问内部信息，而是提供了公共的接口（方法）让外部程序进行操作和访问
封装的目的：
1：隐藏了类的实现细节
2：可以通过加入逻辑控制来操作和访问属性
3：可以进行数据检查，实现对属性的访问控制
为了实现封装，java中提供了四种访问权限
1：private
2:default
3:protected
4:public
2继承
好处： 可以获得父类的全部成员变量和方法
Java中允许创建分等级层次的类，既就是通过一个类继承另外一个类，那么该类可以直接使用被继承的类中的属性和方法（处私有外）
关键字：extends
继承的特征
1：
只允许单继承，既就是一个类只能继承一个类
2;
继承的关系是传递的
3：
继承提高了代码的复用性
方法的重写
发生在继承期间，子类拥有与父类相同的方法名，相同的参数类型和个数，返回值类可以一致也可以是其子类，访问权限不能缩小父类的访问权限，也叫方法覆盖
如果子类的属性和父类的属性同名了，那么子类的属性会覆盖父类的属性（但是内存仍然有两块）
Super： 在当前对象中访问直接父类中被隐藏（重名）的属性和方法
不能出现在静态方法中
子类继承父类，创建子类对象的时候构造方法将如何别调用？？
总是先调用父类
1：子类构造没有super，则系统默认调用父类的无参构造
2：子类构造如果有super，则根据super显示调用父类的响应构造
3：子类构造如果有this，则先调用子类的其他构造，其他构造中如果没有super，则默认调用父类的无参构造，如果有super，则根据super显示调用父类的相应构造
4：父类中如果没有无参构造，而有有参构造，那么子类在继承期间，必须子类构造方法中通过super显示调用父类的有参构造
初始化快：属于类的第四种成员（成员变量，成员方法，构造器），通常用于完成类中的一些初始化操作
初始化快可以划分为静态初始化块和非静态初始化块
静态初始化块：和对象无关，只要类被加载，就会执行类中的静态初始化
语法：static{ }
非静态初始化块：和对象有关，在调用构造方法之前，由系统默认调用
语法： { }
final:表示最终的意思，可以用来修饰类，修饰方法，修饰变量，修饰对象
final类：表示该类不可继承
final方法：表示该方法不可被重写
final变量：表示符号常量
final对象:表示该对象无法再指向其他实例
Object:java中所有的类的父类
常用方法如下
- equals用来比较两个对象的地址是否相同
同一种引用类型使用==比较地址
- toString() 返回对象的符号地址
多态
Java程序中的引用变量有两种数据类型，一种是编译时类型，还有一种是运行时类型，编译时引用变量是由前面所声明的类型决定，而运行时类型是由程序在运行期间给引用变量赋的值来确定，既就是同一种引用类型指向不同的实例来完成不同的操作，就是多态
向上转型：使用父类的引用指向子类的对象
为什么需要向下转型？
因为父类的引用需要访问子类中特有的方法
向下转型：（引用类型的强制转换），先向上转型，然后将父类应用强制类型转换为子类类型
语法：A（父类） B（子类）
A a=new B（）
B b =(B) a
instanceof 判断一个对象是否属于某种类型，通常配合 if 使用 语法：
If（对象名 instanceof 引用类型）{
}
作用：为了避免向下转型中出现的类型转换错误
抽象类：如果一个类中没有足够的信息来描述一个对象，就可以把该类定义为抽象类
特点：
1,抽象类中可以定义成员变量，成员方法，构造方法，初始化快，抽象方法
2：抽象类不能实例化，所以抽象类必须要被继承
3：抽象类中的抽象方法必须要被重写，而普通方法可以选择性的重写
抽象类和普通类的区别？
1:抽象类必须使用abstract来修饰
抽象类不可以创建一个实例，
必须得被继承
抽象方法和普通方法的区别？
抽象方法是在普通方法前面加上abstract修饰，并且把普通方法的方法体去掉
抽象方法必须被子类重写才有意义，普通方法选择性的重写
接口：在java中属于一种特殊的抽象类，接口体现的是一种规范，所有实现接口的类必须遵守该接口
关键字：interface, 语法：
public interface 接口名{
}
接口中所拥有的成员
1：静态常量 默认可以缺省public static final
2:抽象方法，默认可以缺省public abstract
从jdk1.8开始，接口中新增的两中成员
3，默认方法
4，类方法（静态方法）
5,接口可以继承接口
6，一个类可以同时实现多个接口
7.一个类可以继承另一个类，同时实现接口 先继承再实现
接口注意事项
1：接口不能实例化，必须要有实现类（实现关键字implements）
2:接口可以实现多态
3.访问接口的静态方法，接口名.静态方法名
4.访问接口的静态常量，接口名.静态常量
5，使用接口的简单工厂模式
抽象类和接口的区别
1：从语法角度：抽象内中可以定义抽象方法，成员变量，构造器，成员方法，初始化快等，而接口中只是公开的静态常量，抽象方法，静态方法，默认方法
2：从使用角度，抽象类注重的是继承关系，而接口体现的是规范和实现分离的设计思想
枚举类
String类的用法
正则表达式的熟练运用
包装类的自动拆箱与自动装箱
如果把一个-128~127之间的正数自动装箱成一个Integer实例时候，实际上是直接指向对应的数组元素，因此-128~127之间的同一个整数自动装箱成Integer实例时，永远都是引用cache数组的同一个元素，但是每次把一个不再-128~127范围内的整数自动装箱成Integer实例时，系统总是重新创建一个Integer实例，既就是new一个Interger 对象出来
/*
*
* Integer:
* 1:实现和基本类型的相互转换
* 2：封装了基本类型的相关属性，和其他对象的转换方法
*
*/
public class TestInteger {
public void fun(int i){
}
public void fun1(String s){
}
public static void main(String[] args) {
TestInteger t = new TestInteger();
//自动装箱：将基本类型转化为对象类型的过程
int i=1;
Integer it =i;
//自动拆箱：将对象类型转化为基本类型的过程
Integer d = 20;
int h = d;
String s = "200";
//将字符串转化为int类型
Integer.parseInt(s);
t.fun(Integer.parseInt(s));
//将int转化为字符串
int r =100;
Integer.toString(r);
t.fun1(Integer.toString(r));
}
}
java的常量池：
1：静态常量池：也叫class常量池，class文件中除了有类，方法等结构信息，还有一个常量池，专门用于保存类中的字面量等信息
2：运行时常量池：jvm在完成类装载后，将class文件中的常量池内容载入到内存中，并保存在方法区。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
