目录
(一)JAVA基础知识:
一:java运行过程:
二:变量
1、命名
三:基本数据类型:
1、八个基本数据类型:
2、常用面试题:
3、类型转换:
四:运算符
五:分支结构
1、 if.....else
六:循环:
1、循环三要素:
2、循环结构
3、三种循环结构如何选择:
4、嵌套循环:
五:数组
1、数组的复制
2、数组的排序
(二) 面向对象知识
一.类和对象的概念
1.什么是类?什么是对象?
2.如何创建类?如何创建对象?
二.方法的相关知识
1. 方法的重载(overload/overloading):
2. 构造方法:
3.this:
4. null:表示空,没有指向任何对象。
5. 抽象方法与抽象类:
三.常量
四.继承
1.继承的理论和概念
2super:
2.方法的重写(override/overriding):重新写、覆盖
五.多态。
1.多态:多种形态
2.向上造型
3.访问控制修饰符和修饰符:
4.static:静态的
5.强制类型转换
六.内部类
1.成员内部类
2.匿名内部类
七.接口
八.面向对象三大特征总结:
*内存管理(渐渐补充)
常用名词:
两种命名规则
byte(字节型)、shout(短整型)、int(整形)、long(长整型)、flout(单精度浮点型)、double(双精度浮点型)、Boolean(布尔型)、char(字符型)
注意要点:
答:
byte:字节型 ,占用1个字节,范围在-128到127.。
shout:短整型,占用2个字节,范围:-2^15到2^15-1
int:整形,占用4个字节,范围:-2^31到2^31-1
long:长整型,占用8个字节,范围:-2^63到2^63
flout:单精度浮点型,占用4个字节
double:双精度浮点型,占用8个字节
Boolean:布尔型,占用1个字节,只有true和false
char:字符型,占用2个字节,0到65535
语法:(要转换数据类型)变量
注意:强制类型转换有可能会丢失精度或者溢出。
两点规则:
算术:+、-、*、/、%、++、--
算数运算符中的4则运算符没有什么可说的就是我们生活中的加减乘除。主要是++,--这两个运算符。
使用++,--时要注意变量存在的位置。
int a=0;
a++; //a++的实际含义就是a=a+1;
++a; //含义也是a=a+1;
不同之处是++a是先加后用,a++是先用后加。
--同理
单独使用时,在前在后都一样
被使用时,在前在后不一样
a++的值为a----------(a--的值为a)
++a的值为a+1--------(--a的值为a-1)
关系:>、<、>=、<=、==、!=
逻辑:&&、||、!
赋值:=、+=、-=、*=、/=、%=
简单赋值运算符:=
扩展赋值运算符:+=、-=、*=、/=、%=
注意:扩展赋值运算符自带强转功能
字符串连接:+
若两边为数字,则做加法运算
若两边出现了字符串,则做字符串连接
任意类型的数据只要和字符串连,结果都会变为字符串类型---同化作用
System.out.println(10+20+""+30); //3030--------String
System.out.println(""+10+20+30); //102030------String
System.out.println(10+20+30+""); //60----------String
条件/三目:boolean?数1:数2
if:
1)语法:
if(boolean){
语句块-------------基于条件执行的语句
}
2)执行过程:
判断boolean的值:
若为true,则执行语句块(整个结束)
若为false,则直接结束
if...else结构:2条路 1)语法:
if(boolean){
语句块1
}else{
语句块2
}
2)执行过程:
判断boolean的值:
若为true,则执行语句块1(整个结束)
若为false,则执行语句块2(整个结束)
3)说明:
语句块1和语句块2,必走其中之一----------2选1
switch...case:多条路
优点:效率高、结构清晰
缺点:只能对整数判断相等
break:跳出switch
循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)
while结构:先判断后执行,有可能一次都不走
do...while结构:先执行后判断,至少走一次
第1要素与第3要素的代码相同时,使用do...while
for结构:应用率高、与次数相关的循环
for(要素1;要素2;要素3){
语句块/循环体---------------反复执行的语句 4
}
break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
先看循环是否与次数相关:
若相关-------------------------------------直接上for
若无关,再看第1要素与第3相互的代码是否相同:
若相同--------------------------------直接上do...while
若不同--------------------------------直接上while
循环中套循环,常常多行多列时使用,一般外层控制行,内层控制列
执行规则:外层循环走一次,内层循环走所有次
建议:嵌套层数越少越好,能用一层就不用两层,能用两层就不用三层
break只能跳出当前一层循环
相同数据类型元素的集合
定义:
初始化:------------------初始化的是数组中的元素
访问:--------------访问的是数组中的元素
通过(数组名.length)可以获取数组的长度(元素个数)
通过下标/索引来访问数组中的元素,下标从0开始,最大到(数组的长度-1)
遍历/迭代:从头到尾挨个走一遍
补充:引用类型数组需要用new个对象来给数组赋值,若想访问应用数组中的对象数据需要用数组元素打点来进行访问
int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); //扩容
- 对象的属性/特征-----------------------------成员变量
- 对象的行为/动作/功能----------------------方法
成员变量又分为静态变量和实例变量:静态方法属于类通常需要类名来打点,实例变量属于对象需要对象名来打点。
6.一个类可以创建多个对象
Student 张三=new Student()//此时我们就创建了一个学生对象名字叫张三(在JAVA中可以使用中文来命名,但是不建议建议使用英文的见名知意此处只做演示)
ok
如何访问成员:访问静态变量一般需要使用类名打点来访问,访问实例变量一般需要使用对象名打点来访问。
方法名+参数列表
此处补充后面会写到方法的重写。详细记两者的区别。
this的用法:
抽象方法:
由abstract修饰
只有方法的定义,没有具体的实现(连{}都没有)
抽象类:
由abstract修饰
包含抽象方法的类必须是抽象类
抽象类不能被实例化(new对象)
抽象类是需要被继承的,派生类:
重写抽象方法---------------变不完整为完整
也声明为抽象类------------一般不这么用
封装共有的属性和行为-------------------代码复用
为所有派生类提供统一的类型----------向上造型(代码复用)
可以包含抽象方法,为所有派生类提供统一的入口(向上造型后能点出来),同时可以达到强制必须重写的目的(相当于制定了一个标准)
static final常量:
必须声明同时初始化
由类名打点来访问,不能被改变
建议:常量所有字母都大写,多个单词用_分隔
编译器在编译时会将常量直接替换为具体的数,效率高
何时用:数据永远不变,并且经常使用
在派生类的构造方法中若没有调用超类的构造方法,则默认super()调用超类的无参构造
方法
在派生类的构造方法中若自己调用了超类的构造方法,则不再默认提供
注意:super()调用超类构造方法,必须位于派生类构造方法的第一行
指代当前对象的超类对象
两同:方法名相同 参数列表相同
重写:发生在父子类中,方法名相同,参数列表相同重载:发生在同一类中,方法名相同,参数列表不同
超类型的引用指向派生类的对象------前面是超类型,后面是派生类型
能点出来什么,看引用的类型
能造型成为的数据类型:超类+所实现的接口
何时向上造型:多种角色能干的事都一样的时候,可以将多种角色统一造型到超类数组中,实现代码复用
说明:1. java 不建议默认访问权限2. 类的访问权限只能是 public 或默认的,类中成员的访问权限如上 4 种都可以3. 访问权限由小到大依次为: private< 默认的
修饰符:
静态变量:
静态方法:
静态块:
强制类型转换,成功的条件只有两种:
引用所指向的对象,就是该类型
引用所指向的对象,实现了该接口或继承了该类
强转时若不满足如上条件,则发生ClassCastException类型转换异常
建议:在强转之前先通过instanceof来判断引用指向的对象是否是该类
instanceof会返回true或false的结果
如果满足强转成功的条件则返回true,否则返回false
何时需要强转:向上造型后,若想访问的东西在超类中没有,则需要强转
封装:
类:封装的是对象的属性和行为
方法:封装的是具体的业务逻辑功能实现
访问控制修饰符:封装的是具体的访问权限
继承:
作用:代码复用
超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的属性和行为
派生类:派生类所特有的属性和行为
单一继承、多接口实现,具有传递性
多态:
所有对象都是多态的,通过向上造型来体现
所有抽象方法都是多态的,通过方法的重写来体现
向上造型、强制类型转换、instanceof判断
由JVM管理
堆:
存储new出来的对象(包括实例变量、数组的元素)
垃圾:没有任何引用所指向的对象
垃圾回收器(GC)不定时到内存堆中清扫垃圾,回收过程是透明的(看不到的),
不一定一发现垃圾就立刻回收,通过调用System.gc()可以建议虚拟机尽快调度GC来回收
实例变量的生命周期:
创建(new)对象时存储在堆中,对象被回收时一并被回收
内存泄漏:不再使用的对象还没有被及时的回收,严重的泄漏会导致系统的崩溃
建议:不再使用的对象应及时将引用设置为null
栈:
存储正在调用的方法中的局部变量(包括方法的参数)
调用方法时,会在栈中为该方法分配一块对应的栈帧,栈帧中存储局部变量(包括方法的参数),
方法调用结束时,栈帧被自动清除,局部变量一并被清除。
局部变量的生命周期:
调用方法时存储在栈中,方法结束时与栈帧一并被清除
方法区:
存储.class字节码文件(包括静态变量、所有方法)
方法只有一份,通过this来区分具体的调用对象
声明方法2:File file=new File(file,"路径");将路径指向到file文件中
使用File时要使用路径,路径可以使用绝对路径,也可以使用相对路径。(推荐使用相对路径,使用相对路径来说代码移植性比较好,具有良好的跨平台性)。
./指当前目录,取决于运行环境,在用IDEA运行Java时,这里指定的当前目录就是当前程序所在的项目目录。
2.1.io流相关概念:
java将IO比喻为"流",即:stream. 就像生活中的"电流","水流"一样,它是以同一个方向顺序移动的过程.只不 过这里流动的是字节(2进制数据).所以在IO中有输入流和输出流之分,我们理解他们是连接程序与另一端 的"管道",用于获取或发送数据到另一端.。
实际应用中,我们可以通过串联一组高级流到某个低级流上以流水线式的加工处理对某设备的数据进行读 写,这个过程也成为流的连接,这也是IO的精髓所在.
文件流是一组低级流,用来读写文件数据的流,用于连接程序与文件(硬盘)负责读与写文件数据。
文件输出流常用构造器
FileOutputStream fos=FileOutputStream(String filename);
FileOutputStream fos=FileOutputStream(File file);
/*上述两种构造器都会在创建时将该文件创建出来(如果该文件不存在才会这样做),自动创建
该文件的前提是该文件所在的目录必须存在,否则会抛出异常。**/