JAVA基础
一、基本类型、数组、枚举类型
1.1 标识符、关键字
1.1.1 标识符
标识符由字母 、数字 、下划线 、美元符号 组成,不能是true、false、null
1.1.2 关键字
1.2 基本数据类型
1.2.1 逻辑类型
常量:true、false 变量:booleanboolean x = true,关闭 = false;
1.2.2 整数类型
int 型
byte 型
1字节,范围-27 ~27 -1 java中不存在byte型常量 short 型
2字节,范围-215 ~215 -1 java中不存在short型常量 long 型
1.2.3 字符类型
常量:用单引号括起 变量:2字节,范围0~216 转义字符:
\n:换行
\t:水平制表
\b:退格
\o:空字符
\r:换行(回车)
\f:换页
\':单引号
\":双引号
\\:反斜线
1.2.4 浮点类型
float 型
4字节,范围10-38 到1038 、-1038 到10-38 常量后缀f 、F double 型
1.2.5 基本数据类型转换
低级赋值高级,自动转换 高级赋值低级,显式转换int x = (int)34.89
1.3 从命令行输入输出数据
1.3.1 输入基本数据
Scanner reader = new Scanner(System.in);
int x = reader.nextInt();
1.3.2 输出基本数据
int x = 1;
System.out.println(x);
数字加空串等于字符串3+"" = "3"
格式控制符(printf)
%d:int型
%c:char型
%f:浮点型,小数点最多六位
%s:字符串
%md:int型占m列
%m.nf:浮点型占m列,小数点保留n位
1.4 数组
1.4.1 声明数组
java不允许在声明 数组的方括号内指定数组元素个数
int a[][];
int[][] a;
people a[];
people[] a;
1.4.2 创建数组
java允许使用int型变量指定数组元素个数 数组变量中存放首元素地址
int x = 10;
int a[] = new int[x];
int a[][] = new int[3][];
a[0] = new int[1];
a[1] = new int[2];
a[2] = new int[3];
1.4.3 数组元素的使用
1.4.5 length的使用
int a = new int a[10];
a.length;
1.4.6 数组的初始化
1.4.7 数组的引用
char型数组让数组和字符串做并置运算才能输出数组的引用
int a[] = new int[10];
System.out.println(a); //输出数组的引用
char a[] = {'你','好'};
System.out.println(a); //你好
System.out.println(""+a); //输出数组的引用
1.4.8 数组的表示格式
int a[] = {1,2,3};
Arrays.toString(a); //[1,2,3]
1.4.9 复制数组
public static void arraycopy(a数组,a索引起点,b数组,b索引起点,a长度);
copyOf 和 copyOfRange 方法
提取长度大于数组长度,后元素取默认值 b.copyOf(a,n) //a中从0开始的n个元素复制到b b.copyOfRange(a,m,n) //a中从索引m开始到索引n-1个元素复制到b
int a[] = {1,2,3};
int b[] = Arrays.copyOf(a,4); //b={1,2,3,0}
int a[] = {1,2,3};
int b[] = Arrays.copyOfRange(a,1,3); //b={2,3}
1.4.10 排序与使用二分法查找
public static void sort(int a[]); //a指定的int型数据按升序排序
public static void sort(int a[],m,n); //从索引m到索引n-1升序排序
public static int binarySearch(int a[],int x); //a事先排序,x存在于a中,返回该元素索引,否则返回一个负数
1.5 枚举类型
enum 枚举名
{常量列表 //常量列表是用逗号分隔的字符序列,符合标识符的规定
}
枚举名 x; //声明枚举变量,x只能取枚举类型中的常量
x = 枚举名.常量;
可以在一个java源文件中只定义枚举类型,单独保存并编译这个源文件得到字节码文件,该字节码文件可被其他源文件中的类使用
文件1.exe
public enum a{
你,好
}
文件2.exe
main{
a x = a.你;
}
枚举类型名.values(); //返回一个数组,数组元素的值与枚举常量依次对应
JDK1.5以后允许switch语句中表达式的值为枚举类型、允许for语句遍历枚举类型中的常量
int a;
enum Color{
红,蓝
}
for(Color x:Color.values()){
switch(x){
case 红: a=1;
case 蓝: a=2;
}
}
二、运算符、表达式、语句
2.1 运算符与表达式
2.1.2 自增、自减运算符
2.1.3 算数运算符的精度
表达式中最高精度低于int,按int计算。精度高于int,按该精度计算
2.1.4 关系运算符
优先级
>:大于 6
<:小于 6
>=:大于等于 6
<=:小于等于 6
==:恒等于 7
!=:不等于 7
2.1.5 逻辑运算符
关系运算符级别高于逻辑运算符 &&和||
也称为短路逻辑运算符 &&:
逻辑与,||:
逻辑或,!:
逻辑非
2.1.6 位运算符
&:
按位与,|:
按位或,~:
按位非,^:
按位异或位运算符可以操控逻辑型数据,&
=且,|
=或,~
=非
2.1.7 instanceof 运算符
二目,左边对象右边类,当左边的对象是右边的类或子类创建的对象时,为true,否则false
2.1.8 运算符的优先级
优先级 描述 符号 1 分隔符 []
()
.
,
;
2 对象、自增、自减、逻辑非 instanceof
++
--
!
3 乘、除 *
/
%
4 加、减 +
-
5 移位运算 >>
<<
>>>
6 大小比较 <
<=
>
>=
7 相等关系 ==
!=
8 按位与 &
9 按位异或 ^
10 按位或 |
11 逻辑与 &&
12 逻辑或 ||
13 三目运算 ?
:
14 赋值运算 =
2.2 语句种类
Java中语句分为6 种,方法调用语句 、表达式语句 、复合语句 、空语句 、控制语句 、package和import语句 控制语句分为条件分支语句 、开关语句 、循环语句
2.3 条件分支语句
2.3.1 if—else 语句
if( ){
}
else if( ){
}
else{
}
2.4 开关语句
2.4.1 switch 语句
表达式与常量值必须是byte、short、int、char或枚举类型数据
switch(表达式){
case 常量值1:
语句
break;
case 常量值2:
语句
break;
default:
语句
}
2.5 循环语句
2.5.1 for 语句
for(表达式1;表达式2;表达式3){
}
数组与for语句:遍历数组 :依次取数组每一个值
声明循环变量的类型和数组类型相同,不可使用已声明变量
for(声明循环变量:数组的名字){
}
int a[] = new int[10];
for(int i:a){
}
枚举类型与for语句:遍历枚举数据(见1.5) 可变参数(见3.3.3)与for语句:
for(声明循环变量:参数代表){
}
2.5.2 do—while 语句
while( ){
}
------------------------
do{
}while( );
2.5.3 break、continue 语句
break:
中断整个循环,continue:
中断本次循环
break;
continue;
三、类与对象
3.1 类
类是组成JAVA程序的基本要素 类名每个单词首字母大写 类体分为变量的声明(成员变量) 、方法的定义(局部变量)
成员变量又分为实例变量 和类变量(静态变量static)
局部变量与成员变量名字相同,成员变量隐藏,使用this 关键字引用 变量非首单词的首字母大写
3.1.1 方法重载
Java中存在两种多态,重载 、重写 重载:方法名相同,参数个数或类型不同
3.1.2 类方法和实例方法
3.2 对象
3.2.1 创建对象
创建对象分为对象的声明 、为对象分配内存 如果类中没有方法,调用默认无参构造方法 整型默认0,浮点型默认0.0,bo0lean型默认false,引用型默认null 当对象调用方法时,局部变量被分配内存空间,方法完毕即刻释放内存
3.2.2 对象的引用和实体
Java的对象在堆(heap)中分配内存,内含成员变量,称为对象的实体(或对象的变量);对象的引用在栈(stack)中分配内存 Java的垃圾回收机制,自动释放不再被引用的实体的空间
3.2.3 匿名对象
new people( ).name = "张三";
-------------------------------------------------------
int n = new Scanner(System.in).nextInt();
3.3 参数传值
3.3.1 基本数据类型参数的传值
3.3.2 引用类型参数的传值
引用型数据包括:对象 、数组 、接口 传递的是引用而非实体 改变引用不影响原引用,改变实体影响原实体
3.3.3 可变参数
声明变量时不指出每个参数名,用•••
表示,每个参数类型必须相同 x是最后一个参数,也称参数代表 ,可用下标运算来表示参数列表中具体参数,x[0]
、x[1]
、x.length
public void a(int···x);
public void b(double a,int···x);
3.4 static 关键字
static:类、静态 内部类可以用static修饰,其余类不行
3.4.1 类变量和实例变量的区别
实例变量分配不同内存空间,类变量分配同一空间,对象共享类变量 程序执行时,类变量分配空间,未创建对象时实例变量不分配空间 类变量空间直到程序执行完毕才释放 类变量可以通过对象和类名访问,实例变量不能类名访问
3.4.2 实例方法和类方法
都可以使用•
调用 程序执行时,创建对象后实例方法才分配入口地址,方法的入口地址被所有对象共享,所有对象不存在时入口地址才取消 程序执行时,类方法分配入口地址,直到程序退出 类方法可以对象和类名调用,实例方法不能类名调用
3.5 this 关键字
this是JAVA关键字,表示某个对象,this可以出现在实例、构造方法中,不可以出现在类方法中
3.5.1 在构造方法中使用this
3.5.2 在实例方法中使用this
this关键字在实例方法中代表正在调用该方法的当前对象 实例方法可以操作类的成员变量
实例成员变量在实例方法中:this.成员变量
static成员变量在实例方法中:类名.成员变量
通常省略this.
和类名.
,成员变量名字和局部变量名相同时不可省略 一个实例方法调用另一个方法时可以省略this.
和类名.
class A{
void f(){
this.g; //等价于 g;
}
void g(){
System.out.println("good");
}
}
3.6 包
使用包的目的是有效区分名字相同的类 package声明包语句package 包名;
JAVA不允许以java.
为开头作包名 省略package语句为无名包
3.7 import 语句
使用import引入包中的类 写在package语句和类的定义之间 通配符*
引用所有类 java.lang为核心类库,自动引用 使用无名包中的类:源文件保存在同一目录中
3.8 访问权限
访问权限是指对象是否可以通过•
运算符操作自己的变量或方法 私有变量、方法:private
只有本类中创建的对象才能调用 受保护的变量、方法:protected
同一包中的对象可以调用 公有变量、方法:public
任何对象都可以调用 友好变量、方法:非以上三个修饰
同一包中的对象可以调用 public类与友好类
public类:用public修饰,任何其他类中使用 友好类:非public修饰,同一包中的类中使用 不能用protected
和private
修饰类 访问权限:public > protected > private 在类中创建对象时,要调用protected
方法,需要对象所在类与方法所在类的始祖类处于同一包中
3.9 基本数据类型的类封装
java提供与基本数据类型相关的类,实现对基本数据类型的封装,存在于java.lang包 封装类:Byte、Integer 、Short、Long、Float、Double、Character 除char外调用byteValue、intValue……返回该对象含有的基本类型数据
3.9.1 自动装箱与拆箱
自动装箱:允许把一个基本数据类型的值直接赋给相对应类的实例
Integer num = 100;
-------------------------------------
装箱过程
int m = 100;
Integer num = new Integer(m);
自动拆箱:允许类的实例直接赋值给基本数据类型变量或当做基本数据类型使用
Integer num = new Integer();
int x = num+num;
-------------------------------------
拆箱过程
int x = num.intValue() + num.Value();
3.10 反编译器和文件生成器
反编译器:使用JDK提供的javap.exe
可以将字节码反编译为源码 文件生成器:使用JDK提供的javadoc.exe
可以制作源文件的HTML格式文档
3.11 内部类与异常类
3.11.1 内部类
一个类中声明另一个类,称为内部类,包含内部类的类称为外嵌类 外嵌类中的变量和方法在内部类中可用 内部类的类体中不可以声明变量和方法,外嵌类的类体中可以用内部类声明对象作为外嵌类的成员 内部类仅供它的外嵌类使用,static类除外,其它类可以使用,但static类不能操作外嵌类的成员变量 内部类对应字节码文件格式是外嵌类名$内部类名
非内部类不能用static修饰
3.11.2 匿名类
3.11.3 异常类
3.11.4 assert 断言语句
使用关键字 assert 声明断言语句 断言语句两种格式:
assert booleanExpression;
当booleanExpression的值为false时,程序从断言语句处停止执行;值为true时,程序从断言语句处继续执行assert booleanExpression:messageException;
当booleanExpression的值为false时,程序从断言语句处停止执行,并输出messageException表达式的值,提示用户;值为true时,程序从断言语句处继续执行 booleanExpression 必须是值为 boolean 型的表达式,messageException 可以是值为字符串的表达式 当使用java解释器直接运行应用程序时,默认关闭断言语句,在调试程序时使用 -ea
启用断言语句
四、继承与接口
4.1 子类与父类
extends声明子类,一个子类只能有一个父类 类的声明中没有使用extends,默认继承java.lang包中的Object类
4.1.1 子类和父类在同一包中的继承性
同一包中,自然继承非private(私有)变量、方法,访问权限保持不变
4.1.2 子类和父类不在同一包中的继承性
不在同一包中,继承public、protected(受保护的)变量、方法,访问权限不变
4.1.3 子类对象的构造过程
当用子类创建对象时,子类构造方法没有指出使用父类的哪个构造方法,默认调用父类不带参构造方法 当用子类创建对象时,子类和父类中的成员变量都分配了内存空间,但只将继承的那部分作为分配给对象的变量(即可以使用) 对象调用子类继承的方法可以使用那些分配了空间对象却不能直接使用的变量(private)
4.2 成员变量的隐藏和方法重写
4.2.1 成员变量的隐藏
只要子类中声明的成员变量和父类成员变量名相同,子类就隐藏了继承的成员变量 子类对象可以调用从父类继承的方法操作隐藏成员变量
4.2.2 方法重写
子类通过重写(Override)可以隐藏已继承的实例方法(方法重写也称方法覆盖) 重写方法:类型和父类方法一致或子类型,名字、参数类型、参数个数与父类方法相同 重写方法既可以操作继承的成员变量,也可以操作子类声明的成员变量,使用super调用隐藏的方法、变量 重写方法不可以降低方法访问权限
4.3 super 关键字
4.3.1 调用父类的构造方法
在子类的构造方法中使用super调用父类的构造方法,super必须是头一条语句 没有写super指明调用的构造方法,默认super();
调用不带参构造方法
4.3.2 调用隐藏的变量和方法
子类使用super.x
、super.play()
调用被隐藏的变量x
和方法play()
当super调用隐藏的方法时,该方法中出现的成员变量指被隐藏的成员变量
4.4 final 关键字
final关键字可以修饰类、成员变量、方法中的局部变量 final修饰类为final类,不能被继承(String类是final类) final方法不允许重写 final修饰变量就是常量,常量没有默认值,需要赋初值
4.5 对象的上转型对象
//B是A的子类
A a; | A a;
B b = new B(); | a = new B();
a = b; |
//称a是b的上转型对象
上转型对象不能调用子类新增的变量和方法 上转型对象可以调用子类继承或隐藏的成员变量,也可以调用子类继承或重写的方法 可以将对象的上转型对象强制转换为一个子类对象,这时具备了所有子类对象的功能
4.6 abstract 类和方法
用abstract修饰的类和方法称为抽象类和抽象方法 abstract方法只允许声明,不允许实现,不允许使用final和abstract修饰同一个方法
abstract 类
abstract类中可以有abstract方法 abstract类不能用new创建对象 如果一个非抽象类是抽象类的子类,它必须重写父类的抽象方法 如果一个抽象类是抽象类的子类,可以重写也可以继承父类的抽象方法
4.7 接口
4.7.1 接口的声明和接口体
接口的声明:interface 接口名
接口体包含常量定义和方法定义两部分,接口体中只有抽象方法,接口体中所有常量和抽象方法的访问权限都是public(可省略public和abstract) 接口中不能有变量
4.7.2 接口的使用
使用关键字implements声明实现的接口,多个接口用逗号隔开 一个类实现了某个接口,必须重写该接口的所有方法,重写时去掉abstract给出方法体,并且用public修饰(防止降低访问权限) 如果一个类实现了某个接口,但没有重写接口中的方法,那么这个类是abstract类 使用import不仅可以引入包中的类,还可以引入包中的接口 类重写的接口方法及常量可以被类的对象调用,而且常量也可以用类名或接口名直接调用 用public修饰接口称为public接口,可以被任何类实现,不加public称为友好接口,只能被同一包中的类实现 如果父类实现了某个接口,子类自然实现该接口 接口也可以被继承,使用extends声明一个接口是另一个接口的子接口,子接口将继承父接口的所有常量和方法
4.7.3 接口回调
接口回调:把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。那么该接口变量就可以调用被类重写的接口方法
五、Java Swing
java 的 java.swing 包和 java.awt 包(java抽象窗口工具包)提供了用来设计 GUI (图形用户界面)的组件类 Java把 Component(组件类)的子类或间接子类创建的对象称为一个组件 Java把 Container(容器类)的子类或间接子类创建的对象称为一个容器 用add()
方法向容器中添加组件,removeAll()
移除全部组件,remove(Component c)
移除指定组件 容器本身也是组件
5.1 窗口
java提供的 JFrame 类的实例是一个底层容器(窗口)其他组件必须被添加到底层容器中 窗口默认被系统添加到显示屏幕上,因此不允许将一个窗口添加到另一个容器中
5.1.1 JFrame 常用方法
JFrame(String s)
创建标题为 s 的窗口setBounds(int a,int b,int width,int height)
窗口初始位置(a,b),宽 width,高 heightsetVisible(boolean b)
设置窗口是否可见,默认不可见setDefaultCloseOperation(int operation)
设置单击关闭图标后程序的处理setResizable(boolean b)
设置窗口是否可调整大小,默认可调整
5.1.2 菜单条、菜单、菜单项
菜单条》菜单》菜单项 菜单条
JMenubar 类负责创建菜单条setJMenubar(JMenubar bar);
只能向窗口添加一个菜单条 菜单
JMenu 类负责创建菜单 JMenu 是 JMenuItem 的子类,菜单本身也是一个菜单项 菜单项
嵌入子菜单
当把一个菜单看做菜单项添加到菜单中时,称这样的菜单为子菜单 菜单上的图标:Icon 图标类声明图标,其子类 ImageIcon 创建图标,setIcon 方法设置图标
setIcon(Icon icon = new ImageIcon("a.png"));
六、集合
6.1 Collection集合
定义的是所有单列集合中共性的方法 所有的单列集合都可以使用共性的方法 没有带索引的方法
6.1.1 List 接口
6.1.2 Set 接口
不允许重复元素、没有索引(不能用普通for循环遍历) TreeSet 集合(实现类)(无序)HashSet 集合(实现类)(无序)
LinkedHashSet 集合(实现类)(有序)
6.1.3 Collection 常用方法
6.2 Iterator 迭代器
迭代: Collection 集合元素的通用获取方式。先判断集合中有无元素,有则取出,再判断,直到全部取出
6.2.1 Iterator 接口
Iterator 迭代器是一个接口,无法直接使用,需要使用Iterator接口的实现类对象,获取方法特殊 Iterator<> 接口有泛型,类型与集合相同 boolean hasNext();
判断有无元素 next();
返回迭代的下一个元素 void remove();
从指定Collection中移除迭代器返回的最后一个元素
Collection<String> coll = new ArrayList();
Iterator<String> it = coll.iterator();//获取迭代器的实现类对象,并把指针指向集合的-1索引
boolean b = it.hasNext();
String s = it.next();//取出元素,指针移后一位
6.2.2 增强 for 循环
int[] a = {1,2,3};
for(int i : a){
System.out.println(i);
}
-------------------------------
ArrayList<String> list = new ArrayList<>();
for(String i : list){
System.out.println(i);
}
6.3 Map 集合
Map<K,V>;
双列集合,K(key)键,V(value)值,K不重复,V可重复,一个K对应一个V,键和值数据类型可以不同
6.3.1 HashMap 实现类
HashMap<K,V>;
集合底层是哈希表,查询速度快JDK1.8之前数组+单向链表 JDK1.8之后数组+单向链表 / 红黑树(当链表长度大于8) 无序集合,存储和取出元素顺序可能不同 LinkedHashMap<K,V>;
HashMap继承类
底层哈希表+链表(保证迭代的顺序) 有序集合,存储和取出元素顺序一致
6.3.2 Map 集合常用方法
public V put(K,V);
添加指定键值对
K不重复返回null;K重复用新V替代旧V,返回旧V Map<String,String> map = new HashMap<>();
String s1 = map.put("王","李1");
System.out.println(s1);
String s2 = map.put("王","李2");
System.out.println(s2);
System.out.println(map);
----------------------------
null
李1
{王=李2}
public V remove(K);
删除指定键值对
Integet s = map.remove("王");//Integer是int包装类,使用Integer而不用int,因为返回null时int无法接收
System.out.println(s);
-------------
李2
public V get(K);
返回指定键所对应的值
Integer s = map.get("王");
System.out.println(s);
-------------
李2
boolean containsKey(K);
判断是否包含指定键
6.3.3 Map 集合遍历键找值
1、用Set<K> keyset();
方法获取Map中所有的键存储为Set集合; 2、用迭代器 / 增强for
遍历Set集合得到所有键; 3、用get();
方法获取键值。
Map<String,String> map = new HashMap<>();
map.put("王","李");
Set<String> set = map.keyset();
-------------------------------------------
遍历方法(1)
Iterator<String> it = set.itrator();
while(it.hasNext()){
String k = it.next();
Integer v = map.get(k);
System.out.println(k+","+v);
}
-------------------------------------------
遍历方法(2)
for(String k : set){
Integer v = map.get(k);
System.out.println(k+","+v);
}
6.3.4