Java学习--简单java语法

简单java语法

1. application与applet：

application：应用程序有main入口
applet：需要嵌在网页中，不可以单独执行

2. javac和java：

javac:编译器（汇编链接）->可执行文件
java：必须靠执行器执行可执行文件
工作时首先确认path,classpath是否正确，其次调用java执行程序时要写带package的类全名

3. 变量：

char：**2**个字节，*unicode*编码
1. 只有基本变量才是存值的,没有unsigned的修饰
引用变量都指向实体

int a=4;
int b=a;//新的实体
String sa="aa";
String sb=sa;//产生的引用类型sb，引用了同一块实体
sa="bb";//sa引用了新的实体

2. 做参数时：
基本类型有形参实参之分
引用类型操作了实际对象实体

4. 没有指针：

引用代替了指针，可以随时改变所指向的实体
类的成员是引用类型时，不同的实例引用同一个实体时要注意变化的发生。

5. 基本类型的包装型：语法糖

Integer I=10;//Integer.valueOf(10);
int i=I;//I.intValue();
<!-- 集合中 -->
Object[] ary={1,"aaa"};//自动把1变成对象

6. 不定长度参数…：语法糖，实质上一个数组

一个函数最多有一个不定参数类型，且要放在最后位置

public static void test(String... args) {
System.out.println(args.getClass());
for (String arg : args) {
System.out.println(arg);
}
}

7. ==比较：

因为java的两种变量类型导致了

1. 基本：==比较值的不同

2. 引用：==比较引用的实体是否是同一个

例外:

1. 浮点数：不用==，用差值

2. NAN:不是一个数，Double.NAN==Double.NAN//false

3. 装箱Integer：-128-127时虽然是对象，因为缓存，==返回true

4. 枚举：直接用==，引用了唯一的实例化

5. 对象：重写equals(),判断内容相等。(同时重写hashcode())

6. String与常量”hello”:jvm会自动引用到同一个常量上去，可以用==比较

String hello="hello", lo="lo";
hello=="hello";//true
hello==other.hello;//true，自动引用到同一个"hello"
hello=="hel"+"lo";//true，常量计算后
hello=="hel"+lo;//false，变量
hello==new String("hello");//false,新new的变量
hello==("hel"+lo).intern();//true,内部化成了常量

8. 算术运算符：

无符号右移：a>>>b
+:字符串连接

9. 表达式：

10. 注释：

/** */:doc注释

11. 控制语句：

switch(a) {case:}:a可以是string
break/continue：加标记控制跳出或继续哪重循环。

12. 数组：

int [5] a;//非法：数组是一个引用类型，需要new，在堆里
length：自带函数返回长度
Arrays.sort(a):自带排序
增强for:只读的

int[] ages=new int[5];
//for(type of item:array)
for(int age:ages){

}

Array.Copy(from,start,to,start,len):自带拷贝函数

// 二维数组：数组的数组
int[][] a=new int[4][];//new数组一定要确定其长度，长度/行为4，类型是int[]
int[][] a=new int[][4];//非法，和cpp不同

13. 接口：所有方法都自动是public abstract

与类的继承关系无关
通过对接口的引用来new具体实例

public interface interface1{}
interface1 my=new concreteclass();

14. 枚举：enum，语法糖是一种特殊的class类型

实际上每个元素都是一个枚举类的实例

15. 注解：语法糖，附加信息给编译器,所有的注解也是一个类

@Override
@Deprecated
@SuppressWarnings

16. 多态：

1. 编译时多态：重载overload
2. 运行时多态（虚方法调用）：重写（覆盖）override
需要向上造型（new时、传参时），且子类要覆盖父类方法
类型确定：instanceof
3. 不是虚方法的情况
1. static:跟实例无关
2. private:无法覆盖
3. final:无法覆盖

17. 构造方法：

任何类都要有构造方法，可以为空。
抽象类也要有，虽然不能被new
基本顺序：
static() ->super()-> {}和定义初始化顺序 ->构造器内其他
1. this，super：最先执行
2. 实例初始化：先于构造器中除了thissuper外执行

class a{
int ia=10;
{
ia=11;
}
}

3. 静态初始化：类加载时执行

class a{
int ia=10;
static{
ia=11;
}
}

18. 垃圾回收：

由java虚拟机（jvm）的垃圾回收线程来完成

引用计数：回收时自动调用finalize()

try-with-resources:代替做资源的释放

try(Scanner in=new Scanner(System.in)){

}
//<!-- 等价 -->
finally{
in.close();
}

19. 内部类和匿名类

内部类：定义在类内部

//<!-- 内部类 -->
public class out{
private class inner{

}
}
//<!-- 静态的嵌套类 -->
public class out2{
static class inner2{

}
}
main{
out a=new out();//a引用一个实例
out.inner b=a.new inner();//内部类是实例a的类
out2 aa=new out2();
out2.inner bb=new out2.inner2();//static和具体实例无关了，只是要
//告诉inner2的全名
}

局部类：定义在成员函数内部
匿名类：一次性使用的类，定义时即new的局部类，没有名字也就没有构造方法

//<!-- 事件监听器 -->
//<!-- 直接使用父类或接口来new，注意语法格式父类后加(){} -->
btnN.addActinListener(new ActionListener(){
@Override
public void actionPerformed(ActionEvent event){
//...
}
})
//<!-- 匿名类：做方法的参数：接口的实例 -->

20. Lambda表达式：匿名类的一个实例，减少重复代码

//参数->表达式形式 重写了匿名类的函数
//()->{} 无参数，返回值是语句
//x->x*x 参数x，返回值x*x
//<!-- 要求接口只能有一个抽象函数 -->
btn.addActionListener(e->{});
//<!-- 例子Comparator -->
Person[] people=new Person[100];
Comparator<Person> compareAge=
(p1,p2)->p1.age-p2.age;
Arrays.sort(people,compareAge);

巨大进步：将代码（重写函数）变成了数据（一个实例）