Java 基础知识汇总-面试

1. 面向对象的编程 Class , object, new, constructor

class ClassName {
// instance variables
// constructors
// accessors (or getters)
// mutators (or setters)
// service methods
}

Class name = new Class(); //声明name 变量并初始化为Class()
name.attribute1=”…”;      //直接引用
name.method();

constructor构造函数：是和class有相同名字的特殊函数，无返回类型，用在变量初始化中,一个class中可以有很多constructor。有默认。

constructor chaining
有继承关系时，new 子类引发constructor chaining
super();  //可以不写是default  // 必须在constructor第一行
this();  //必须在constructor第一行 // within the class
两者不可在同一个constructor中存在

3. 循环、判断：
   break continue。Break 离开循环；continue 忽略后面语句，直接回到循环开头。删除线格式
4. 变量范围
   

 - 成员变量指的是声明在一个类中，但在方法、构造方法和语句块之外的变量 *不需要显式初始化*
 - 类变量从该类的准备阶段起开始存在， 直到系统完全销毁这个类，类变的作用域与这个类的生存范围相同；
 - 实例变量从该类的实例被创建起开始存在，直到系统完全销毁这个实例，实例变量的作用域与对应实例的生存范围相同；
 - 局部变量指的是声明在方法、构造方法或者语句块中里的变量。*必须要显式初始化*。
 - 形参：在定义方法签名时定义的变量，形参的作用域在整个方法内有效。
 - 方法局部变量：在方法体内定义的局部变量，它的作用域是从定义该变量的地方生效，到该方 法结束时失效。
 - 代码块局部变量：在代码块中定义的局部变量，这个局部变量的作用域从定义该变量的地方生 效，到该代码块结束时失效。

4. 关键词

static         方便在没有创建对象的情况下来进行调用（方法/变量）。比如 Math.max()
	variable   和class 共存亡,所有instance共用一份class variables
			   不允许用来修饰局部变量
	method     不可以访问instance method or variable(不带static的变量和方法)
			   //因为这些都是必须依赖具体的对象才能够被调用
			   不可以有this，super关键字。//同理，都无对象，更没有这些关键字
               必须被实现，不可以是抽象的。
    代码块      在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次
    
final
	variable 	值不能改  
			 	在声明或在constructor或在使用时初始化，可修饰成员变量和局部变量
			 	final reference must reference the same object whose content can be modified.
	method   	不能被重写
	class    	不能被继承,其中的method默认为final  // abstract class反之。
	
this 指向当前对象本身的指针  this.variable  this.method();
super 指向最近的父类的指针 super.variable   super.method();
也可以用在调用constructor上： //指的对象，均不可在static环境中用
super(); //可以不写是default  // 必须在constructor第一行
super(name);//调用父类形式一样的constructor//必须第一行
   this();  //必须在constructor第一行 // within the class
this(name);//调用同一类形式一样的constructor//必须第一行

this https://www.cnblogs.com/ly20171219/p/8085146.html
Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。

5. Java ⾯向对象编程三⼤特性: 封装、继承、多态
6. 封装 encapsulation

封装把⼀个对象的属性（variable，method）私有化，外界无需了解具体实现，同时提供⼀些可以被外界访问的属性的⽅法。 比如Java object的用法。

7. 继承 inheritance ：override, extends, superclass, subclass

使用继承子类将会得到父类中所有的域和方法。父类中的私有域和方法将被隐式继承，非私有方法和域将被显式继承。
只能有一个父类，可以有多个子类。
override:子类可以重写父类的方法
super
this
例子：https://www.cnblogs.com/myworld7/p/10395928.html

8. 多态 polymorphism

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
多态体现为父类引用变量可以指向子类对象
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
父类类型 变量名=new 子类类型();  //向上转型

- 在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。  
- 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

9. abstract

抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类
abstract class: 
 1. 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
 2. 可以作为Datatype， People[] p = new People[10];
 3. 抽象类必须被继承，才能被使用。
 4. 抽象类中不一定要包含abstract方法。也就是了，抽象中可以没有abstract方
 5. 一旦类中包含了abstract方法，那类该类必须声明为abstract类。
 6. 抽象类与接口（interface）有很大的不同之处，接口中不能有实例方法去实现业务逻辑，而抽象类中可以有实例方法，并实现业务逻辑
 7. 抽象类不能使用final关键字修饰，因为final修饰的类是无法被继承，而对于抽象类来说就是需要通过继承去实现抽象方法，这又会产生矛盾
abstract method:
 1. 抽象方法不能有方法主体，（没有{}包起来的业务逻辑）：public abstract void eat();
 2. 必须在subclass中被override
 3. 抽象方法不能用private修饰，因为抽象方法必须被子类实现（覆写），而private权限对于子类来说是不能访问的，所以就会产生矛盾
 4. 抽象方法也不能用static修饰，试想一下，如果用static修饰了，那么我们可以直接通过类名调用，而抽象方法压根就没有主体，没有任何业务逻辑，这样就毫无意义了。

10. interface 接口

-解决了multiple inheritance 的问题
-相当于一个abstract class ，但是所有method不可以有内容
-例如 Comparable interface

public interface Flyable{
public void fly();      
int wingsNumber = 2;            
}
public class FlyingSquirrel extends Creature implements Flyable{
…} 
接口中的所有成员变量都默认是由public static final修饰的，可省略public static final，因此接口还常常被用来当做定义常量的集合：
接口中的所有方法都默认是由public abstract修饰的。
接口没有构造方法。构造方法用于创建对象。abstract class 有。
1. class 只能 extends一次，但可以implements 多次
2. 不可以初始化
3. interface 之间也有继承
interface Father{}
interface Mother{}
interface Child extends Father,Mother{}
4. 可实现多态

---------------------------------------------------
和 abstract class 相同如下
1 不能被初始化
2 有抽象函数
和 abstract class 区别如下
1 关键字不同，个数不同
interface被继承时用的关键字是implements，而且可以同时implements多个interface。
abstract class被继承时用的关键字是extends，而且只能同时extends一个abstract class。
2 变量的限定词
interface内定义的成员对象都是static & final & public的。
abstract class可以自己定义。
3 方法
interface所有的方法全部都是抽象的，public的。无构造函数。
abstract class内申明abstract的方法不能有实现，非申明abstract的方法可以有默认实现。可有构造函数。
5. 设计
abstract class表示的是”is-a”关系。
interface表示的是”like-a”关系。

11. 代码重用 code reuse ：

composition， aggregation，inheritance， interface
ref:https://blog.csdn.net/simonezhlx/article/details/8855297

Composition表示的是'Part-of'的关系，Engine是Car的一部分,脱离Car的Engine是没有实在意义的；而Aggregation表示的是'Has-a'的关系，Person有一个Address，但是Addess的存在是不依赖Person的，换句话说，地址本身就有其独立存在的意义，有没有人都是没有关系的。

composition-----------------
public class Engine {}
public class Car
{
    Engine e = new Engine();
}

aggregation---------------- 
public class Address {} 
public class Person
{
     private Address address;
     public Person(Address address)
     {
         this.address = address;
     }
}

从两个代码片段中，我们不难看出Engine的生命周期是与Car一致的，何时Car被回收了，那Engine也就不存在了
但是反观Address，它是在Person之外创建的，所以即使Person被回收了，Address也不一定马上也会回收。（取决于是否有指向它的其它链接） 

12. 设计模式
    MVC
    singleton

单例模式是设计模式中最常见也最简单的一种设计模式，保证了在程序中只有一个实例存在并且能全局的访问到。
实现方式：https://blog.csdn.net/goodlixueyong/article/details/51935526

factory
adapter
strategy pattern

13. 异常处理

checked exceptions: recovery is possible    
unchecked exceptions : runtime exceptions, 无需catch

 try- throw  层层上抛，也必须处理
 try -catch - finally   finally必定会执行，catch有报错才执行
 常见：IOException, 

14. JAVA IO
15. JAVA JDBC
    连接数据库，方便写sql
16. Java collection : set, list, queue 详见另一篇笔记
17. 多线程 详见另一篇笔记

小知识点：

• pass-by-reference VS pass-by-value

Pass-by-reference(传递的是地址) 函数传递array时，操作改变的是原array而非copy，所以函数操作完后array会改变。
Pass-by-value(传递的是拷贝的值) 函数传递 int double等时，操作改变的是copy，函数操作完后原值不会被改变。

• 自动装箱，拆箱 ：autobox, autounbox
• access control: private, default, protected, public L4,P9

private 只有同一个class可用，subclass也不可用
protected 包内所有类可见，包外有继承关系的子类可见
default表示默认，不仅本类访问，而且是同包可见。

• 重载 method overload: 函数名字相同，参数不同 ，返回值可不同
• 类型转换 Integer.parseInt(args[0]);
• stack heap

heap : instance variables
stack: local variables，包括指向object的

object 的记忆空间在编译时未分配，在运行时new自动分配

• 垃圾回收机制

objects becomes eligible for GC
a)	reference out of scope
b)	reference is assigned to another object, there is no longer reference pointing to it.
c)	set reference to null              NullPointerException

• public static void main(String[] args){}
• instanceof : if (variable instanceof type)