记录重要知识点，避免被知识遗忘。
文章目录
- 1.基本结构
- 2.数据类型
- 3.逻辑运算
- 4.this变量
- 5.可变参数
- 6.参数绑定
- 7.构造方法
- 8.多构造方法
- 9.方法重载
- 10.继承
- 11.向上向下转型
- 12.多态
- 13.抽象类
- 14.接口
- 15.静态字段(变量)和静态方法
1.基本结构
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello World!")
}
}
//注释
/**
*多行注释
*/
/*
这也是一种多行注释
*/类名首字母大写，方法名首字母小写；
Java入口程序规定的方法必须是静态方法，方法名必须为main，括号内的参数必须是String数组。
2.数据类型
计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从0000000011111111，换算成十进制是0255，换算成十六进制是00~ff。内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。
float类型可最大表示3.4x1038，而double类型可最大表示1.79x10308。
char类型使用单引号’，且仅有一个字符，要和双引号"的字符串类型区分开。
变量前加上final就会变为常量，常量名通常全部大写。
注意变量的作用域，定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名。
3.逻辑运算
移位运算：int n=7; n=n<<1; //n=14
对两个整数进行位运算，实际上就是按位对齐，然后依次对每一位进行运算。
位运算：与：&； 或：|； 非：~； 异或：^;
三元运算符：
语法形式：布尔表达式 ？ 表达式1 ：表达式2
运算过程：如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值
转义字符：
4.this变量
在方法内部，可以使用一个隐含的变量this，它始终指向当前实例。因此，通过this.field就可以访问当前实例的字段。如果没有命名冲突，可以省略this。
class Person {
private String name;
public String getName() {
return name; // 相当于this.name
}
}但是，如果有局部变量和字段重名，那么局部变量优先级更高，就必须加上this
class Person {
private String name;
public void setName(String name) {
this.name = name; // 前面的this不可少，少了就变成局部变量name了
}
}5.可变参数
可变参数用类型…定义，可变参数相当于数组类型：
class Group {
private String[] names;
public void setNames(String... names) {
this.names = names;
}
}上面的setNames()就定义了一个可变参数。调用时，可以这么写：
Group g = new Group();
g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入3个String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String
g.setNames("Xiao Ming"); // 传入1个String
g.setNames(); // 传入0个String
完全可以把可变参数改写为String[]类型：
class Group {
private String[] names;
public void setNames(String[] names) {
this.names = names;
}
}但是，调用方需要自己先构造String[]，比较麻烦。例如：
Group g = new Group();
g.setNames(new String[] {"Xiao Ming", "Xiao Hong", "Xiao Jun"}); // 传入1个String[]另一个问题是，调用方可以传入null：
Group g = new Group();
g.setNames(null);而可变参数可以保证无法传入null，因为传入0个参数时，接收到的实际值是一个空数组而不是null
6.参数绑定
调用方把参数传递给实例方法时，调用时传递的值会按参数位置一一绑定。
那什么是参数绑定？
我们先观察一个基本类型参数的传递：
// 基本类型参数绑定
public class Main {
public static void main(String[] args) {
Person p = new Person();
int n = 15; // n的值为15
p.setAge(n); // 传入n的值
System.out.println(p.getAge()); // 15
n = 20; // n的值改为20
System.out.println(p.getAge()); // 15还是20?
}
}
class Person {
private int age;
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
}运行代码，从结果可知，修改外部的局部变量n，不影响实例p的age字段，原因是setAge()方法获得的参数，复制了n的值，因此，p.age和局部变量n互不影响。
结论：基本类型参数的传递，是调用方值的复制。双方各自的后续修改，互不影响。
我们再看一个传递引用参数的例子：
// 引用类型参数绑定
public class Main {
public static void main(String[] args) {
Person p = new Person();
String[] fullname = new String[] { "Homer", "Simpson" };
p.setName(fullname); // 传入fullname数组
System.out.println(p.getName()); // "Homer Simpson"
fullname[0] = "Bart"; // fullname数组的第一个元素修改为"Bart"
System.out.println(p.getName()); // "Homer Simpson"还是"Bart Simpson"?
}
}
class Person {
private String[] name;
public String getName() {
return this.name[0] + " " + this.name[1];
}
public void setName(String[] name) {
this.name = name;
}
}注意到setName()的参数现在是一个数组。一开始，把fullname数组传进去，然后，修改fullname数组的内容，结果发现，实例p的字段p.name也被修改了！
结论：引用类型参数的传递，调用方的变量，和接收方的参数变量，指向的是同一个对象。双方任意一方对这个对象的修改，都会影响对方（因为指向同一个对象嘛）。
有了上面的结论，我们再看一个例子：
// 引用类型参数绑定
public class Main {
public static void main(String[] args) {
Person p = new Person();
String bob = "Bob";
p.setName(bob); // 传入bob变量
System.out.println(p.getName()); // "Bob"
bob = "Alice"; // bob改名为Alice
System.out.println(p.getName()); // "Bob"还是"Alice"?
}
}
class Person {
private String name;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}不要怀疑引用参数绑定的机制，试解释为什么上面的代码两次输出都是"Bob" 。
自己的理解：
第一种基本类型参数：外部的局部变量n传入实例中是将n的值拷贝了一份给了age，所以外部的变量值的变化对实例中的值没有影响；
第二种引用类型参数：外部的字符串数组传入实例是将fullname数组的地址指向传给了this.name，当数组的元素被修改，即指向的内容被修改了，地址没发生变化，所以实例p的字段name也跟着变化；
第三种引用类型参数：将外部的字符串bob地址传给this.name，此时bob和name都指向“Bob”，当bob变化指向"Alice"时，实例p的字段name指向未发生改变，还是指向“Bob”，所以两次输出都是"Bob"。
补充：局部变量和成员变量：
作用域：方法内部的是局部变量，在整个类内可见的是成员变量；
赋值：成员变量Java会赋初始值，局部变量不会；
优先级：同名时局部变量优先级高。
补充：JAVA中初始化的顺序:
- 加载类；
- 静态变量初始化；
- 静态块/静态方法；【其只能调度静态的，不能调度非静态的】
- 成员变量；
- 构造方法；
7.构造方法
构造方法没有返回值（也没有void），调用构造方法，必须用new操作符。
如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来：
// 构造方法
public class Main {
public static void main(String[] args) {
Person p1 = new Person("Xiao Ming", 15); // 既可以调用带参数的构造方法
Person p2 = new Person(); // 也可以调用无参数构造方法
}
}
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}8.多构造方法
可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分；
一个构造方法可以调用其他构造方法，这样做的目的是便于代码复用。调用其他构造方法的语法是this(…)；
9.方法重载
这种方法名相同，但各自的参数不同，称为方法重载（Overload）。
注意：方法重载的返回值类型通常都是相同的。
10.继承
继承有个特点，就是子类无法访问父类的private字段或者private方法。例如，Student类就无法访问Person类的name和age字段；
这使得继承的作用被削弱了。为了让子类可以访问父类的字段，我们需要把private改为protected。用protected修饰的字段可以被子类访问；
在Java中，任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();
子类不会继承任何父类的构造方法。子类默认的构造方法是编译器自动生成的，不是继承的。
11.向上向下转型
Java提供了instanceof操作符，可以先判断一个实例究竟是不是某种类型：
Person p = new Person();
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Student); // false
Student s = new Student();
System.out.println(s instanceof Person); // true
System.out.println(s instanceof Student); // true
Student n = null;
System.out.println(n instanceof Student); // falseinstanceof实际上判断一个变量所指向的实例是否是指定类型，或者这个类型的子类。如果一个引用变量为null，那么对任何instanceof的判断都为false
12.多态
引用多态和方法多态：
多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。例如：
Person p = new Student();
p.run(); // 无法确定运行时究竟调用哪个run()方法有童鞋会问，从上面的代码一看就明白，肯定调用的是Student的run()方法啊。
父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；
同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。
但是，假设我们编写这样一个方法：
public void runTwice(Person p) {
p.run();
p.run();
}它传入的参数类型是Person，我们是无法知道传入的参数实际类型究竟是Person，还是Student，还是Person的其他子类，因此，也无法确定调用的是不是Person类定义的run()方法。
所以，多态的特性就是，运行期才能动态决定调用的子类方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法。
public class Main {
public static void main(String[] args) {
// 给一个有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税:
Income[] incomes = new Income[] {
new Income(3000),
new Salary(7500),
new StateCouncilSpecialAllowance(15000)
};
System.out.println(totalTax(incomes));
}
public static double totalTax(Income... incomes) {
double total = 0;
for (Income income: incomes) {
total = total + income.getTax();
}
return total;
}
}
class Income {
protected double income;
public Income(double income) {
this.income = income;
}
public double getTax() {
return income * 0.1; // 税率10%
}
}
class Salary extends Income {
public Salary(double income) {
super(income);
}
@Override
public double getTax() {
if (income <= 5000) {
return 0;
}
return (income - 5000) * 0.2;
}
}
class StateCouncilSpecialAllowance extends Income {
public StateCouncilSpecialAllowance(double income) {
super(income);
}
@Override
public double getTax() {
return 0;
}
}观察totalTax()方法：利用多态，totalTax()方法只需要和Income打交道，它完全不需要知道Salary和StateCouncilSpecialAllowance的存在，就可以正确计算出总的税。如果我们要新增一种稿费收入，只需要从Income派生，然后正确覆写getTax()方法就可以。把新的类型传入totalTax()，不需要修改任何代码。
可见，多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。
13.抽象类
如果一个class定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用abstract修饰。
因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。
使用abstract修饰的类就是抽象类。我们无法实例化一个抽象类
面向抽象编程的本质就是：
上层代码只定义规范（例如：abstract class Person）；
不需要子类就可以实现业务逻辑（正常编译）；
具体的业务逻辑由不同的子类实现，调用者并不关心。
14.接口
Java的接口特指interface的定义，表示一个接口类型和一组方法签名，而编程接口泛指接口规范，如方法签名，数据格式，网络协议等
15.静态字段(变量)和静态方法
用static修饰的字段，称为静态字段，静态字段可以被所有的实例访问；
用static修饰的方法称为静态方法。调用实例方法必须通过一个实例变量，而调用静态方法则不需要实例变量，通过类名就可以调用。
1.静态方法中可以直接调用同类中的静态成员并只能访问静态字段，不能直接调用非静态成员。原因是Java初始化的顺序；
2.如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
3.静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
一个.java文件只能包含一个public类，但可以包含多个非public类。如果有public类，文件名必须和public类的名字相同。
