JAVA高级语法1：基础

实例化：

不实例化，就是一个空指针

注意，即使只是声明，也是会分配空间的:

来源：https://zhidao.baidu.com/question/519582801799420045.html?qbl=relate_question_3
我们要看你这句int a处于什么地方，如果是在方法内部中被执行到，也就是说是局部变量，就会在栈内存中分配内存，由于是int型，所以就是4字节，也就是32bit，long类型的才会是64bit。
而你说的表示地址我们称为堆内存。创建的对象以及对象中的方法和数据是存储在堆内存中的。JVM会在栈内存中建立对象的引用，然后当执行到new语句时，在堆内存中创建对象，这时就将这个对象的类型以及这块区域的内存地址值赋给引用，然后进行对象中数据的初始化。也就是说，对象的引用存储在栈内存中，存放的是类型以及hash值，如Integer@0xff67。而对象里的内容实际上是存储在堆内存中的。
如果你这句int a只是在某个对象内作为成员变量，那么根本不会涉及到栈内存。a就存储在它所在的那个对象的堆内存中。明白了么？

所以说，如果是成员变量的话，如果是基本类型，会在声明时直接在栈上给该类似的大小的内存空间；如果是引用类型，会在栈上给一个指针的大小。

对变量的分类

实例变量只有实例化之后才能使用，而类变量直接用类名就可以使用

成员变量在堆，局部变量在栈
匿名对象

new Person().shout();

使用场景：
1. 对一个对象只需要一次方法调用
2. 作为实参传递给方法
方法的重载

参数的个数或者参数的数据类型必须不同
可变个数的形参
1. (String[] args)//定义字符串数组
2. （String... args)//JAVA特有的点点点的方式，这种参数在使用时与数组的使用方式相同
两种方法的区别：

? 第一种如果没有参数，需要输入null或者一个空数组；而第二种直接不填就好(...代表可以传递0到多个参数)
方法的参数传递

JAVA只有一种参数传递方法：值传递。即将实际参数值复制到方法的形参中，而参数本身不受影响（当然这种方法比较慢，但是JAVA吗23333）

注意，对于引用对象，值还是变化了的，因为传进去的实际是地址。但是即使修改了函数里的指针指向（例如在函数中new了一个对象并将指针指向了该对象)，外部的实际指向也不会受影响，相当于指向了两个不同的对象而已
this关键字

使用this的几个优点：
1. 不需要给方法中的形参乱起名字了
  
  如图，使用this的话，形参的名称可以和成员变量相同，赋值的时候借助this区分就好，这样就不需要在函数的形参上乱起名字了
2. 增强程序阅读性
3. this可以作为一个类中，构造器相互调用的特殊格式
  
  用于构造器重载时，可以直接调用已有的构造器然后进行修改即可，使构造器的编写更加方便
  
  注意，这种情况下，this()必须放在构造器的首行（显然）
JAVA Bean

也就是说，符合这三条的都可以叫做javaBean

右键-》source-》general getters and setters,自动生成get和set方法
继承（extends)和多态

JAVA只支持单继承

继承让类与类之间产生了关系，不要仅仅为了获取其他类中的某个功能而去继承-》继承是要有逻辑关系在其中的
方法的重写(@override)
- 重写只能重写方法体，名称、参数列表和返回值类型均不能改
- 重写方法不能使用比被重写方法更加严格的访问权限
- 子类方法抛出的异常不能大于父类被重写方法的异常
题外话：ctrl+/：eclipse快速注释代码

如果子类和父类在同一个包下，那么对于父类的成员修饰符除了private之外，剩下的情况子类都可以使用父类的成员变量；如果不在一个包下，只有protected和public的成员变量可以使用
super关键字

super和this类似，但是是用于调用父类的成员变量和方法的。

使用super,子类可以调用父类之上的所有父类层级

this和super的区别：

在子类中，通过This或者super调用构造器，只能使用一个，因为都要占据第一行
类对象的实例化过程

有继承时：

在方法区，先加载父类方法，再加载子类方法

子类构造方法先入栈，父类再入栈，所以父类先执行
instanceof操作符

instance：实例

属于子类也行
Object类

也叫基类
形参定义为object类型，则可以接受任何类型的类（注意，必须是个类！）
- equal:比较引用对象：是否引用了同一个对象（也就是一个new出来的对象）
```
Person e=new person();
Person p=new person();//此时e和p指向的是堆中的两个不同的对象，此时用equal方法检测是false
e=p;//此时e被重定向到p，此时再检测就是true了
```
对象的类型转换

能进行的是有继承关系间的类型的转换

从子类到父类：

?
由此可见，object对象可以接收任何类型的对象

从父类到子类：

?
示例代码：

e可以接受父类为Person类的各种类的对象，然后检查其是否是Student类或Student类的子类，如果是，就执行Student类中独有的方法，否则执行其他方法。
==操作符和equals方法

只有指向同一个对象，==才为true，而比较的不是成员变量的值是否相等

equals和==功能相同，除了下面说的几个特殊情况：

注意String的比较要使用equals而不是==
String对象的创建

可以看到，无论是哪一种方法，同样的字符串也不会保留多个

--所以字面量创建更加省内存，所以其常用

而“不重复”只全体现在常量池上，如果使用New的方式，堆中每次都会创建一个新的对象。最特别的是最后一种情况，常量池中添加的是拼接钱的串，而堆中创建的却是拼接后的串
包装类

将基本数据类型赋予了类的方法
- 自动拆箱、装箱：和基本数据类型写法可以保持一致（转换更简单，使用起来比基本数据类型更方便、功能更强大）
- 包装类的功能：
  
  借助包装类的类方法，将字符串转换为对应类型的数据（注意，只是借助其实现转换，并没有直接使用包装类）
  1. 字符串转其他基本数据类型
  int i=Integer.parseInt("123");
  
  boolean b=Boolean.parseBoolean("false");
  1. 其他基本数据类型转字符串
  String istr=String.valueOf(i);
  
  String batr=String.valueOf(b);
  
  ->综上，包装类主要应用于字符串和其他基本数据类型的应用
重写toString()

toString方法是直接用System.out.printIn()打印时调用的方法。默认的toString()是类Object的方法，由于其是所有类的父类，所以其功能比较泛，该方法就是输出内存地址（大多数情况下这是没什么用的）。所以各个类可以重写该方法以打印有意义的内容。
static关键字

static用来设置类属性和类方法

static一般只用Public修饰

类属性被所有对象所共用，可以用来计数什么的
单例设计模式--设计模式之一
- 什么是设计模式？
  
  设计模式就是实际编程中逐渐总结出来的一些解决问题的套路
- 单例
  
  只有一个实例（实例化对象）
  
  在整个软件系统运行过程中，这个类只被实例化一次，以后不论在哪都只调用这一个实例
- 应用的场景：
  1. 该对象的创建要消耗大量的时间和资源
  2. 重复new对象没有必要
- 两种实现方式：
  1. 先构造后使用
    
    构造方法私有化，不能new
    
    实例化也是私有的，引用是私有的类变量
    
    利用公有的方法返回那个类变量
    
    这样的话，程序中永远只有一个实例化对象
  2. 先不构造，用的话再构造，如果从来不用就算了，就这一点区别
    
    先判断(s1==null)来判断是否需要实例化
理解main方法

?
例如cmd,即可给main传参
初始化代码块

作用：对JAVA对象进行初始化

类的成员初始化过程：声明成员变量默认值-》显示初始化，执行代码块-》执行构造方法
- 静态代码块
  
  静态代码块用于初始化静态属性
  
  非静态代码块每次new都要重新执行，而静态代码块只执行一次。且静态先于非静态执行
在实际应用中，静态代码块用的比较多，用于初始化静态类属性（尤其对于一些比较复杂的静态类属性，例如属性是一个类的情况下），非静态的作用不太大
匿名内部类

对Person类的方法进行了重载，所以其其实是一个Person的子类，故称为匿名内部类

匿名内部类中成员变量的初始化（如果要和父类的初始化有所不同的话）无法通过构造方法实现（因为没有类名，无法创建构造方法），只能通过代码块的方式完成
final关键字

概况一下，final修饰的内容初始化之后就不能再修改了，所以变量要均大写，和常量保持一致（final修饰的变量是常量，常量必须显式赋值）

final static:全局常量
抽象类

含有抽象方法的类必须被声明为抽象类

注意，抽象类中不一定所有方法都是抽象的，如果都是抽象的就是接口了

final和abstract是冲突的

抽象类可以有构造方法
模板方法设计模式--设计模式之二
- *
接口

接口中只有定义，没有实现

interface定义，implements使用

类可以实现多个接口，多个接口之间用,分割

当有一个新的需求时：
- 如果父类新增抽象方法，子类就必须实现，否则就需要定义为抽象类。
- 解决方法就是不要在父类中新增抽象方法，而是新增一个接口，由子类去选择是否实现这一接口
  
  父类需要稳定的抽象，不能总是在改
需要描述一个交叉的关系时：
- 不能使用类的继承解决这个问题：会污染类的继承，使继承关系没有逻辑性
- 实现接口就好（接口是一类方法（动作）的集合）
对抽象类和接口的总结：
- 抽象类是对于一类事物的高度抽象，其中既有属性也有方法
- 接口是对方法的抽象，也就是对一系列动作的抽象
- 当需要对一类事物抽象的时候，应该使用抽象类，好形成一个父类；当需要对一系列动作抽象时，就使用接口
匿名内部类在接口中的应用

看到了以下一段代码：

这里的Runnable是接口，我们知道接口是不能实例化对象的，那这里是什么情况呢？

其实这不是声明了一个接口类型的对象，而是一种多态机制，专业名词叫“匿名内部类”，实际上是创建了一个遵守了该接口的普通类（Object)对象。

类似的使用还有下面，可以看到，类能声明的接口几乎都可以声明
```
interface  Shape {
    void  draw();
}
public class Main {
  // interface type as instance variable
  private Shape myShape;

  // interface type as parameter type for a constructor
  public Main(Shape s) {
    this.myShape = s;
  }

  // interface type as return type of a method
  public Shape getShape() {
    return this.myShape;
  }

  // interface type as parameter type for a method
  public void setShape(Shape s) {
    this.myShape = s;
  }

  public void letItSwim() {
    // interface type as a local variable
    Shape locaShape = null;

    locaShape = this.myShape;

    // interface variable can invoke methods
    // declared in the interface and the Object class
    locaShape.draw();
  }
}
```
这其实是一种变相的“用接口作为类型”，也是面向接口的编程的思想之一。
工厂模式——设计模式之三

在真正的开发工作中，都是合作开发，每个开发人员写一部分，集合到一起成为一个项目

问题：一个开发人员要改代码，例如改类名，会影响其他人的工作。因此降低了工作效率

解决方法：写一个产品接口类，一个工厂接口类，其他人用工厂类而不是直接用产品类。通过工厂将new对象隔离，通过产品的接口接受不同实际产品的实现类，实例的类名的改变不影响其他合作开发人员的编程。其他开发人员只需要关注工厂类的使用，而修改代码只限于产品类的名称和工厂类的代码，不会影响工厂类的使用。（这种设计可能是架构师的任务(?ω?)）

无论是内部类还是其他，JAVA除了很早期的一些特征外，剩下的特征都是为了解决一些特点问题必不可少的，不是冗余的功能
内部类

内部类是外部类的成员

注意外部类调用内部类时方法

内部类可以声明private 或者protected

内部类的声明和外部类互相不影响，可以重名

内部类的作用：
- 内部类的最大作业是实现多重继承（A想同时获得类B和类C的方法并重写）

JAVA高级语法1：基础

匿名内部类在接口中的应用