标识符由字母 数字 、下划线 、美元符号 常量：true、false 变量：booleanboolean x = true,关闭 = false; int 型
byte 型
1字节，范围-27 ~27 -1 java中不存在byte型常量 short 型
2字节，范围-215 ~215 -1 java中不存在short型常量 long 型
常量：用单引号括起 变量：2字节，范围0~216 转义字符： \n:换行
\t:水平制表
\b:退格
\o:空字符
\r:换行（回车）
\f:换页
\':单引号
\":双引号
\\:反斜线
float 型
4字节，范围10-38 到1038 、-1038 到10-38 常量后缀f 、F double 型
低级赋值高级，自动转换 高级赋值低级，显式转换int x = (int)34.89 Scanner reader = new Scanner(System.in);
int x = reader.nextInt();
int x = 1;
System.out.println(x);
数字加空串等于字符串3+"" = "3" 格式控制符（printf） %d：int型
%c：char型
%f：浮点型，小数点最多六位
%s：字符串
%md：int型占m列
%m.nf：浮点型占m列，小数点保留n位
java不允许在声明 数组的方括号内指定数组元素个数 int a[][];
int[][] a;
people a[];
people[] a;
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];
int a = new int a[10];
a.length;
char型数组让数组和字符串做并置运算才能输出数组的引用 int a[] = new int[10];
System.out.println(a); //输出数组的引用
char a[] = {'你','好'};
System.out.println(a); //你好
System.out.println(""+a); //输出数组的引用
int a[] = {1,2,3};
Arrays.toString(a); //[1,2,3]
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}
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中，返回该元素索引，否则返回一个负数
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;
}
}
表达式中最高精度低于int，按int计算。精度高于int，按该精度计算 优先级
>:大于 6
<:小于 6
>=:大于等于 6
<=:小于等于 6
==:恒等于 7
!=:不等于 7
关系运算符级别高于逻辑运算符 &&和||也称为短路逻辑运算符 &&:逻辑与，||:逻辑或，!:逻辑非&:按位与，|:按位或，~:按位非，^:按位异或位运算符可以操控逻辑型数据，&=且，|=或，~=非 二目，左边对象右边类，当左边的对象是右边的类或子类创建的对象时，为true，否则false 优先级 描述 符号 1 分隔符 [] () . , ;2 对象、自增、自减、逻辑非 instanceof ++ -- !3 乘、除 * / %4 加、减 + -5 移位运算 >> << >>>6 大小比较 < <= > >=7 相等关系 == !=8 按位与 &9 按位异或 ^10 按位或 |11 逻辑与 &&12 逻辑或 ||13 三目运算 ? :14 赋值运算 =
Java中语句分为6 种，方法调用语句 、表达式语句 、复合语句 、空语句 、控制语句 、package和import语句 控制语句分为条件分支语句 、开关语句 、循环语句 if( ){
}
else if( ){
}
else{
}
表达式与常量值必须是byte、short、int、char或枚举类型数据 switch(表达式){
case 常量值1：
语句
break；
case 常量值2:
语句
break；
default：
语句
}
for(表达式1；表达式2；表达式3){
}
数组与for语句：遍历数组 ：依次取数组每一个值
声明循环变量的类型和数组类型相同，不可使用已声明变量 for(声明循环变量：数组的名字){
}
int a[] = new int[10];
for(int i:a){
}
枚举类型与for语句：遍历枚举数据（见1.5） 可变参数(见3.3.3)与for语句： for(声明循环变量:参数代表){
}
while( ){
}
------------------------
do{
}while( );
break:中断整个循环，continue:中断本次循环break;
continue;
类是组成JAVA程序的基本要素 类名每个单词首字母大写 类体分为变量的声明(成员变量) 、方法的定义(局部变量)
成员变量又分为实例变量 和类变量(静态变量static)
局部变量与成员变量名字相同，成员变量隐藏，使用this 关键字引用 变量非首单词的首字母大写 Java中存在两种多态，重载 、重写 重载：方法名相同，参数个数或类型不同 创建对象分为对象的声明 、为对象分配内存 如果类中没有方法，调用默认无参构造方法 整型默认0，浮点型默认0.0，bo0lean型默认false，引用型默认null 当对象调用方法时，局部变量被分配内存空间，方法完毕即刻释放内存 Java的对象在堆(heap)中分配内存，内含成员变量，称为对象的实体(或对象的变量)；对象的引用在栈(stack)中分配内存 Java的垃圾回收机制，自动释放不再被引用的实体的空间 new people( ).name = "张三";
-------------------------------------------------------
int n = new Scanner(System.in).nextInt();
引用型数据包括：对象 、数组 、接口 传递的是引用而非实体 改变引用不影响原引用，改变实体影响原实体 声明变量时不指出每个参数名，用•••表示，每个参数类型必须相同 x是最后一个参数，也称参数代表 ，可用下标运算来表示参数列表中具体参数，x[0]、x[1]、x.length public void a(int···x);
public void b(double a,int···x);
static：类、静态 内部类可以用static修饰，其余类不行 实例变量分配不同内存空间，类变量分配同一空间，对象共享类变量 程序执行时，类变量分配空间，未创建对象时实例变量不分配空间 类变量空间直到程序执行完毕才释放 类变量可以通过对象和类名访问，实例变量不能类名访问 都可以使用•调用 程序执行时，创建对象后实例方法才分配入口地址，方法的入口地址被所有对象共享，所有对象不存在时入口地址才取消 程序执行时，类方法分配入口地址，直到程序退出 类方法可以对象和类名调用，实例方法不能类名调用 this是JAVA关键字，表示某个对象，this可以出现在实例、构造方法中，不可以出现在类方法中 this关键字在实例方法中代表正在调用该方法的当前对象 实例方法可以操作类的成员变量
实例成员变量在实例方法中：this.成员变量 static成员变量在实例方法中：类名.成员变量 通常省略this.和类名.，成员变量名字和局部变量名相同时不可省略 一个实例方法调用另一个方法时可以省略this.和类名. class A{
void f(){
this.g; //等价于 g;
}
void g(){
System.out.println("good");
}
}
使用包的目的是有效区分名字相同的类 package声明包语句package 包名; JAVA不允许以java.为开头作包名 省略package语句为无名包 使用import引入包中的类 写在package语句和类的定义之间 通配符*引用所有类 java.lang为核心类库，自动引用 使用无名包中的类：源文件保存在同一目录中 访问权限是指对象是否可以通过•运算符操作自己的变量或方法 私有变量、方法：private只有本类中创建的对象才能调用 受保护的变量、方法：protected同一包中的对象可以调用 公有变量、方法：public任何对象都可以调用 友好变量、方法：非以上三个修饰同一包中的对象可以调用 public类与友好类
public类：用public修饰，任何其他类中使用 友好类：非public修饰，同一包中的类中使用 不能用protected和private修饰类 访问权限：public > protected > private 在类中创建对象时，要调用protected方法，需要对象所在类与方法所在类的始祖类处于同一包中 java提供与基本数据类型相关的类，实现对基本数据类型的封装，存在于java.lang包 封装类：Byte、Integer 、Short、Long、Float、Double、Character 除char外调用byteValue、intValue……返回该对象含有的基本类型数据 自动装箱：允许把一个基本数据类型的值直接赋给相对应类的实例 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();
反编译器：使用JDK提供的javap.exe可以将字节码反编译为源码 文件生成器：使用JDK提供的javadoc.exe可以制作源文件的HTML格式文档 一个类中声明另一个类，称为内部类，包含内部类的类称为外嵌类 外嵌类中的变量和方法在内部类中可用 内部类的类体中不可以声明变量和方法，外嵌类的类体中可以用内部类声明对象作为外嵌类的成员 内部类仅供它的外嵌类使用，static类除外，其它类可以使用，但static类不能操作外嵌类的成员变量 内部类对应字节码文件格式是外嵌类名$内部类名 非内部类不能用static修饰 使用关键字 assert 声明断言语句 断言语句两种格式：
assert booleanExpression;当booleanExpression的值为false时，程序从断言语句处停止执行；值为true时，程序从断言语句处继续执行assert booleanExpression:messageException;当booleanExpression的值为false时，程序从断言语句处停止执行，并输出messageException表达式的值，提示用户；值为true时，程序从断言语句处继续执行 booleanExpression 必须是值为 boolean 型的表达式，messageException 可以是值为字符串的表达式 当使用java解释器直接运行应用程序时，默认关闭断言语句，在调试程序时使用 -ea 启用断言语句 extends声明子类，一个子类只能有一个父类 类的声明中没有使用extends，默认继承java.lang包中的Object类 同一包中，自然继承非private(私有)变量、方法，访问权限保持不变 不在同一包中，继承public、protected(受保护的)变量、方法，访问权限不变 当用子类创建对象时，子类构造方法没有指出使用父类的哪个构造方法，默认调用父类不带参构造方法 当用子类创建对象时，子类和父类中的成员变量都分配了内存空间，但只将继承的那部分作为分配给对象的变量(即可以使用) 对象调用子类继承的方法可以使用那些分配了空间对象却不能直接使用的变量(private) 只要子类中声明的成员变量和父类成员变量名相同，子类就隐藏了继承的成员变量 子类对象可以调用从父类继承的方法操作隐藏成员变量 子类通过重写(Override)可以隐藏已继承的实例方法(方法重写也称方法覆盖) 重写方法：类型和父类方法一致或子类型，名字、参数类型、参数个数与父类方法相同 重写方法既可以操作继承的成员变量，也可以操作子类声明的成员变量，使用super调用隐藏的方法、变量 重写方法不可以降低方法访问权限 在子类的构造方法中使用super调用父类的构造方法，super必须是头一条语句 没有写super指明调用的构造方法，默认super();调用不带参构造方法 子类使用super.x、super.play()调用被隐藏的变量x和方法play() 当super调用隐藏的方法时，该方法中出现的成员变量指被隐藏的成员变量 final关键字可以修饰类、成员变量、方法中的局部变量 final修饰类为final类，不能被继承(String类是final类) final方法不允许重写 final修饰变量就是常量，常量没有默认值，需要赋初值 //B是A的子类
A a; | A a;
B b = new B(); | a = new B();
a = b; |
//称a是b的上转型对象
上转型对象不能调用子类新增的变量和方法 上转型对象可以调用子类继承或隐藏的成员变量，也可以调用子类继承或重写的方法 可以将对象的上转型对象强制转换为一个子类对象，这时具备了所有子类对象的功能 用abstract修饰的类和方法称为抽象类和抽象方法 abstract方法只允许声明，不允许实现，不允许使用final和abstract修饰同一个方法 abstract类中可以有abstract方法 abstract类不能用new创建对象 如果一个非抽象类是抽象类的子类，它必须重写父类的抽象方法 如果一个抽象类是抽象类的子类，可以重写也可以继承父类的抽象方法 接口的声明：interface 接口名 接口体包含常量定义和方法定义两部分，接口体中只有抽象方法，接口体中所有常量和抽象方法的访问权限都是public(可省略public和abstract) 接口中不能有变量 使用关键字implements声明实现的接口，多个接口用逗号隔开 一个类实现了某个接口，必须重写该接口的所有方法，重写时去掉abstract给出方法体，并且用public修饰(防止降低访问权限) 如果一个类实现了某个接口，但没有重写接口中的方法，那么这个类是abstract类 使用import不仅可以引入包中的类，还可以引入包中的接口 类重写的接口方法及常量可以被类的对象调用，而且常量也可以用类名或接口名直接调用 用public修饰接口称为public接口，可以被任何类实现，不加public称为友好接口，只能被同一包中的类实现 如果父类实现了某个接口，子类自然实现该接口 接口也可以被继承，使用extends声明一个接口是另一个接口的子接口，子接口将继承父接口的所有常量和方法 接口回调：把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。那么该接口变量就可以调用被类重写的接口方法 java 的 java.swing 包和 java.awt 包（java抽象窗口工具包）提供了用来设计 GUI （图形用户界面）的组件类 Java把 Component(组件类)的子类或间接子类创建的对象称为一个组件 Java把 Container(容器类)的子类或间接子类创建的对象称为一个容器 用add()方法向容器中添加组件，removeAll()移除全部组件，remove(Component c)移除指定组件 容器本身也是组件 java提供的 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)设置窗口是否可调整大小，默认可调整菜单条》菜单》菜单项 菜单条
JMenubar 类负责创建菜单条setJMenubar(JMenubar bar); 只能向窗口添加一个菜单条 菜单
JMenu 类负责创建菜单 JMenu 是 JMenuItem 的子类，菜单本身也是一个菜单项 菜单项
嵌入子菜单
当把一个菜单看做菜单项添加到菜单中时，称这样的菜单为子菜单 菜单上的图标：Icon 图标类声明图标，其子类 ImageIcon 创建图标，setIcon 方法设置图标
setIcon(Icon icon = new ImageIcon("a.png")); 定义的是所有单列集合中共性的方法 所有的单列集合都可以使用共性的方法 没有带索引的方法 不允许重复元素、没有索引(不能用普通for循环遍历) TreeSet 集合(实现类)(无序)HashSet 集合(实现类)(无序)
LinkedHashSet 集合(实现类)(有序)迭代： Collection 集合元素的通用获取方式。先判断集合中有无元素，有则取出，再判断，直到全部取出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();//取出元素，指针移后一位
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);
}
Map<K,V>;双列集合，K(key)键，V(value)值,K不重复，V可重复，一个K对应一个V，键和值数据类型可以不同HashMap<K,V>;集合底层是哈希表，查询速度快JDK1.8之前数组+单向链表 无序集合，存储和取出元素顺序可能不同 LinkedHashMap<K,V>;HashMap继承类
底层哈希表+链表(保证迭代的顺序) 有序集合，存储和取出元素顺序一致 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);判断是否包含指定键
1、用Set<K> keyset();方法获取Map中所有的键存储为Set集合；迭代器 / 增强for遍历Set集合得到所有键；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);
}
251
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
