javase复习
了解Java
java是世界上使用排前三的高级编程语言
1.JDK、JRE、JVM之间的关系
JDK：开发工具包，提供给Java程序员使用，包含JRE、以及Java c编译器等。
JRE：Java运行时环境、包含JVM、Java基础类库，是运行Java程序的环境。
JVM：Java虚拟机，运行Java代码。
2.数据类型
分为基本数据类型（8种）和引用数据类型。
Java八种数据类型的分类（图）
基本数据类型分为三大类
由图可知，我们继续按照Java的基本数据类型可以分为三大类：
①数值型
数值型数据（metric data）是按数字尺度测量的观察值，其结果表现为具体的数值。现实中所处理的大多数都是数值型数据。
②字符型
字符型（Character）数据是不具计算能力的文字数据类型，用字母C表示。
它包括中文字符、英文字符、数字字符和其他ASCⅡ字符，其长度（即字符个数）范围是0-255个字符，即0x00至0xFF。
③布尔型
布尔数据是sql server中的一个名词，布尔数据由binary（二进制）数字组成，即0和1。
数值型
整数类型（byte,short,int,long）
数值型可以分为两大类：①整数类型 ②浮点类型
对于图标中类型的对应表数范围和占用的存储空间解释一下：
①比特(bit)：比特是英文 binary digit的缩写。比特是表示信息的最小单位，是二进制数的一位包含的信息或2个选项中特别指定1个的需要信息量。一般来说，n比特的信息量可以表现出2的n次方种选择。
有多少个数值，就是几bit
②表数的范围：就拿byte的范围-128到127之间，声明byte类型变量的时候赋值不能超过这个范围，给byte类型变量赋值时不能超过这个范围
byte a = 130 这就是一个错误的示范，超出了范围
byte a = 120 就正确了
浮点型(float,double)
字符型（char）
注意转义字符：拿单个单引号来说，‘’‘ 这样是不行的，需要在前面加一个转义字符 / ， ‘/’’ ，认为其就是单个单引号
布尔类型（boolean）
3.数据类型
隐式转换：数据范围小的，转为数据范围大的。
强制转换：可能会精度丢失。
类型提升：不同的类型相互运算：数据类型小的会提升为数据类型大的。short、byte不足四字节，运算时会先转成int计算。
int->long float->double
int转String：String.valueOf(str) String转int: Integer.parseInt(int)
3.常量变量（访问修饰符）
程序在执行过程中其值是不可以改变的量叫做常量
语法:【访问权限】final 数据类型 常量名=初始值
例子：public final int COUNT=0;
注意事项
在定义常量时就需要对该常量进行初始化。
final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。
为了与变量区别，常量取名一般都用大写字符。
常量的初始化,还可以放在类构造器中进行初始化(该常量未被static修饰):
引用类型的常量,不可变指的是地址不可变,但是对象里的值是可变的:
(2) 变量
程序在执行过程中其值是可以改变的量叫做变量
语法:【访问权限】 数据类型 变量名【=初始值,可以初始化,也可以不用进行初始化】;
下图给出的是8种数据类型,所占存储空间,表示的范围和默认值:
注意:
局部变量必须进行初始化即赋值，才能使用（它没有默认值）
全局变量可以不进行初始化,使用对应数据类型的默认值(未规定数据类型的时候,整型默认:int,浮点默认:double)。
(3)局部变量和全局变量
局部和全局意思可理解为该变量可访问的范围,局部变量可访问为对应所在{}代码块的区域，而全局变量在整个Class的{}代码块下,意思就是在本类都可以进行访问(无需关注访问权限)，并且全局变量可以被其他类(同包,非同包)进行访问,前提是访问权限足够(该全局变量足够开放)。
public class demo{
int a;//全局变量
public void start(){
int c;//局部变量
}
public void start2(int c){ //c 局部变量
}
}
(4)访问权限
主要用于其他类(本包,非本包,非本包子类,非本包非子类)对目标类进行访问时根据权限来看该类是否可以进行访问。
注意:
- default：表示不加任何访问修饰符(通常称为“默认访问权限“或者“包访问权限”)
3.数据类型转换（自动类型转换，强制类型转换）
(1).自动类型转换(隐式转换)
当数据类型不一样时，将会发生数据类型转换。
特点:代码不需要进行特殊处理，自动完成。
规则:数据范围从小到大。
🔻(右面100是未规定数据类型,即该数据类型默认为int,左边为long,右边int数据类型的数据放入long(小->大)发生了自动类型转换。)
long num=100;
1
右面2.5F规定了数据类型为float,(如果不加F表示数据类型为double),左面数据类型为double(小->大)发送了自动类型转换。
double num2 = 2.5F;
1
由于浮点数默认使用double,在使用float的时候需要在右侧加上f,不然会报错:
(2).强制类型转换(显示转换)
如果数据类型没有发生自动转换，也可以通过强制类型进行转换但是这样可能会导致数据丢失。
特点:代码需要进行特殊的格式处理，不能自动完成。
格式:范围小的类型 范围小的变量名= (范围小的类型)原本范围大的数据;
🔻(右面数据类型为long,左面数据类型为int(大->不发生自动类型转换),(int)表示该long数据类型强制转换为int。)
int num = (int) 100L ;
1
备注:
强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
byte/short/char这三种类型都可以发生数学运算，例如加法“+”
byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
int和浮点类型之间可以进行强制类型转换
char可以通过强制类型转换为int,对应的值为字符的ASCLL的值
对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，那么java编译器将会自动隐含地补上一个(byte)(short)(char)。)
如果没有超过左侧的范围，编译器自动隐含地补上(byte)进行强转。
byte num1 = /*(byte)*/ 30; //右侧没有超过左侧的范围
System.out.println(num1); // 30
如果右侧超过了左侧范围，那么编译器报错。
4.运算符
运算符 用于连接 表达式 的 操作数，并对操作数执行运算。
运算符速查表：
运算符优先级：
(1) 关于++和- -
count++:表示先
执行再运算
++count:表示先运算再执行
备注:“--”同理//关于count++
int count=0;
System.out.println(count++);//0
System.out.println(count);//1
int count1=0;
count1++;
System.out.println(count1);//1
//关于++count
int count2=0;
System.out.println(++count2);//1
int count3=0;
++count3;
System.out.println(count3);//1
(2)关于&&,||与&,I
(&&,||)表示如果前面一项表达式已经满足要求了后面一项的表达式就无需再进行相应的判断了。如下:count=100已经满足表达式1(count>=100)对于表达式2(count<500)就不用进行判断,但是条件为“|”时,表达式1和表达式2都要进行运算(这就是短路与与短路或的作用)。
int count=100;
if (count>=100||count<500) {
System.out.println("执行");
}
(3)关于三目运算
三目运算表达式进行判断之后，表达式为true返回 “:” 左面的值,如果为false返回 “:” 右面的值。int count=100;
boolean result=(count==100?true:false);
System.out.println(result);//true5.表达式，顺序，选择（if，if else else if/switch），循环（while（））；do{}while；for；for增强
(1)表达式
表达式运算后的结果要么为真要么为假语法:变量/常量 比较运算 变量/常量 【逻辑运算】 变量/常量 比较运算 变量/常量
🔻(下面的表达式a>b,a<B可以分别看作一个小的表达式,整体可以看作是一个大的表达式)。
例子:a>b&&a<B(2)选择
if(表达式){
//执行符合表达式要求的代码
}
if(表达式1){
//执行符合表达式1的代码
}else if(表达式2){
//执行符合表达式2的代码
}
if(表达式1){
//执行符合表达式1的代码
}else if(表达式2){
//执行符合表达式2的代码
}else{
//执行不满足所有不符合表达式1和表达式2的代码
}
🔻注意: switch中只有当遇到break的时候才退出(意思就是当switch满足情况1的情况下，执行情况1的代码，但是情况1结尾处如果没有break就继续执行情况2的代码直到遇到break才退出)。switch(变量/常量){
case 变量/常量(同一数据类型):
//执行满足该情况的代码
break;
case 变量/常量(同一数据类型):
//执行满足该情况的代码
break;
default:
//执行不满足所有上面情况的代码
break;
}
在JDK1.8中,switch支持的参数如下图所示:
(2)循环
break:结束本循环
continue:结束本次循环
i的变化:i=0,1,2,3…19 当i=20的时候执行i<20不满足本次循环结束for(int i=0;i<20;i++){
//执行20次 i的变化:i=0,1,2,3.....19 当i=20的时候执行i<20不满足本次循环结束
}
备注:for的执行顺序为i = 0,然后i<20,方法题{}中的代码,i++,再然后执行i<20,方法题{}中的代码,i++,后面按到此顺序循环直到i<20不满足条件为止。for(集合泛型数据类型:集合)增强
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
arrayList.add("4");
for(String aString:arrayList){
System.out.println(aString);//允许情况:1 2 3 4
}
备注:泛型类型指的是一组数据集合中共同采用的数据类型,是对一组数据类型的限定。while(表达式)直到表达式为false才停止循环
while (表达式) {
//直到表达式为false停止循环
}
do{}while(表达式);先执行一次,然后当表达式为false时停止循环do{
//先执行一次,然后当表达式为false时停止循环
}while(表达式);
6.数组
存放一组相同数据类型的数据。
(1)声明数组变量
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：数据类型[] 数组名; // 首选的方法
数据类型 数组名[]; // 效果相同，但不是首选方法
实例:double[] myList; // 首选的方法
double myList[]; // 效果相同，但不是首选方法
(2)创建数组
下面的10表示数组的长度
myList= new double[10];
另外一种创建数组的方式:数据类型[] 数组名= {value0, value1, ..., valuek};
(3)数组的访问
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。🔻(表示访问数组myList索引为0的对应数据。)
myList[0];
🔻(myList.length:表示获取myList数组的长度)myList.length;
实例:public class TestArray {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println("总和为： " + total);
}
}
7.OOP编程
(1) 方法
避免代码臃肿,将某一个操作的代码移到定义的方法中,当用户需要执行该操作时,只需要调用该方法即可,程序就会进入到方法中去执行该操作的代码。方法语法如下:
[访问权限] [static] [..] 返回值类型 方法名([形参1][形参2]..[形参n]){
//当方法被使用时执行代码块的代码
return 返回值类型;
}关于方法的返回值类型为void:
表示没有返回值，不用写
return 返回值类型数据类型就是基本数据类型或者引用数据类型,但是数据类型不一致会报错。返回数据类型为void就不用写
return 返回值类型:返回数据类型(int)和返回的数据类型(String)不一致会报错:
(2).类
类是一个模板，它描述一类对象的行为和状态,在Java中Object类是所有类的基类(父类)。
(3).对象
对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
关于类(模板的基本语法)
对于学生我们可以看成是一个类Student,对于学生这个类(模板),我们可以通过属性和方法进行简单的描述,属性描述学生的信息,这个学生叫什么名字,年龄,家庭地址,班级号等，这个类(模板)的属性越多,对应的对象(模板的实例)的信息就越详细,方法描述学生的行为,比如,吃饭,睡觉,喝水,跑步,对应的类的方法越多,相应的对象的就越生动形象。
public class Student { //属性 public String name; public int age; public int classNum; public String address; //方法(行为) public void eat() { System.out.println("吃饭"); } public void stuInfo() { System.out.println(toString()); } public String toString() { return "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"; } }关于什么是匿名类
当我们要去使用某个抽象类/接口的时候我需要做的就是写一个子类来继承该抽象类/实现该接口，然后通过在子类中重写对应的方法，在外部通过实例化该子类，再调用相应的方法，从而实现了对该抽象类/接口的使用，匿名内部类就是不用去写这个抽象类/接口的子类，直接创建该子类，并重写相应的方法，从而实现了对该抽象类/接口的使用。
对象如何创建实例:
对象创建:类名 对象名=new 类名();//无参构造创建对象
对象的创建:类名 对象名=new 类名(参数,参赛...);//有参构造创建对象(类名(参数,参赛…)对应类的构造方法)
方法调用:对象.方法名()
对象属性的访问/赋值:对象.属性名; /对象.属性名=属性值;
(这种方式需要注意属性的访问权限，后面会用get,set进行访问和设置)public class Test { public static void main(String[] args) { Student admin=new Student(); admin.name="张三"; admin.age=10; admin.classNum=2; admin.address="奈何桥"; //学生信息 admin.stuInfo(); //执行eat()方法 admin.eat(); } }关于对象的比较(==和equals()):
对于==
对于基本数据类型，“==”就只看两个数据的值是否相等。比如两个int 型的变量，就只看两个变量的值是否相等。
对于引用数据类型，“==”就只看两个数据的堆内存地址。比如两个new的User对象，new一次就新分配一个内存空间，因此两个new的User对象堆内存地址值就是不一样的。
关于重写和重载:
重写:重新写一个将原来方法进行覆盖了，调用的时候调用自己重写的方法重载:多写一个或多个方法名相同的方法但是形参一定不同(形参的数据类型,形参的长度),返回数据类型可以不同,这样就可以同一个方法有多种加载方式。//重写Object下的toString() public String toString() { return "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"; } //【1】重载toString()方法 public String toString(int a) { return "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"; } //【3】形参的长度不同 public String toString(int a,int b) { return "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"; } //【4】形参的数据类型不同 public String toString(String a) { return "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"; } //【5】返回数据可以不同 public void toString(String a,int c) { System.out.println( "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"); }(4)三大特性(封装,继承,多态)
封装:封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
属性私有化,公有访问,通过get(),set()接口进行访问和初始化
有参构造方法初始化对象—>多个参数一起进行初始化(减少访问次数),可创建多个不同形参的构造方法提供多种初始化方案
封装的优点：提高代码的安全性。
提高代码的复用性。
“高内聚”：封装细节，便于修改内部代码，提高可维护性。
“低耦合”：简化外部调用，便于调用者使用，便于扩展和协作
对上面代码进行优化：
public class Student { //属性 private String name; private int age; private int classNum; private String address; public Student() { // TODO Auto-generated constructor stub } public Student(String name, int age, int classNum, String address) { this.name = name; this.age = age; this.classNum = classNum; this.address = address; } //方法(行为) public void eat() { System.out.println("吃饭"); } public void stuInfo() { System.out.println(toString()); } public String toString() { return "Student [name=" + name + ", age=" + age + ", classNum=" + classNum + ", address=" + address + "]"; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age>0&&age<300) { this.age = age; } this.age=0; } public int getClassNum() { return classNum; } public void setClassNum(int classNum) { this.classNum = classNum; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } }注意：在idea中可以使用快捷键生成（alt+insert）
有的笔记本使用fn+alt+insert
8.集合（Set，List，Map）
13.集合(Set,List,Map)
数组存放数据时需要先设置存放数据的容量大小,并且在删除数据的时候效率较低,为了更好的对数据进行处理,根据数据结构的不同,线程的安全性等多方面考虑,Java集合Api提供了丰富的集合操作,让我们对数据进行更优的处理。集合体系:
Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中， 所以当使用集合框架的时候需要进行导包。
Set和List的区别
Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变<实现类有ArrayList,LinkedList,Vector> 。
ListList的主要实现：ArrayList， LinkedList， Vector。 ArrayList LinkedList Vector
List常用常用方法:
实例练习
public static void main(String[] args) { //创建List对象 List<String> list=new ArrayList<String>();//多态 //集合初始化 for (int i = 0; i < 10; i++) { list.add("数据:"+i);//数据0,数据1.....数据9 } System.out.println("遍历集合:"); //遍历结合 for (String str : list) { System.out.println(str); } System.out.println("获取序号为0的值："); //获取集合指定位置的值 System.out.println(list.get(0)); System.out.println("获取集合末尾的值："); System.out.println(list.get(list.size()-1));//list.size()获取集合的长度 System.out.println("序号为0的值被移除之后,序号0的值变为了:"); //删除序号为0的值 list.remove(0); //获取序号0的值 System.out.println(list.get(0)); }
浙公网安备 33010602011771号