java基础

标识符

​ 标识符是用来给变量、类、方法以及包进行命名的，如Welcome、main、System、age、name、gender等。标识符需要遵守一定的规则：

• 标识符必须以字母、下划线_、美元符号$开头。
• 标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
• Java 标识符大小写敏感，且长度无限制。
• 标识符不可以是Java的关键字。

标识符的使用规范

• 表示类名的标识符：每个单词的首字母大写，如Man, GoodMan
• 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(), eatFood()

【注意】：Java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的国际字符集。因此，这里字母的含义不仅仅是英文，还包括汉字等等。但是不建议大家使用汉字来定义标识符！

合法的标识符

int  a = 3;
int  _123 = 3;
int  $12aa = 3;
int  变量1 = 55;  //合法，但是不建议使用中文命名的标识符

不合法的标识符

int  1a = 3;   //不能用数字开头
int  a# = 3;   //不能包含#这样的特殊字符
int  int = 3;  //不能使用关键字

变量的本质

​ 变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。

​ Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。 比如，int a=3; 表示a变量的空间大小为4个字节。

​ 变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。

变量的分类

局部变量(local variable)

方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须```先声明、初始化(赋初值)再使用```。

public void test() {
   int i;
   int j = i+5 ; // 编译出错，变量i还未被初始化 
} 
  
public void test() {
   int i;
   i=10;
   int j = i+5 ; // 编译正确
}

成员变量（也叫实例变量 member variable）

  方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会```自动初始化```成该类型的默认初始值。

静态变量（类变量 static variable）

​ 使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。 (注：讲完内存分析后我们再深入！先放一放这个概念！)如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值。

代码实例

public class TestVariable {
 
    int a;            //成员变量, 从属于对象； 成员变量会自动被初始化
    static  int  size;   //静态变量，从属于类
     
    public static void main(String[] args) {
 
        {
            int age;        //局部变量，从属于语句块；
            age = 18;
        }
         
        int salary = 3000;    //局部变量，从属于方法
 
        int gao = 13;
        System.out.println(gao);
 
        int i;
    //    int j = i + 5; // 编译出错，变量i还未被初始化
         
    }
}

基本数据类型(primitive data type)

	Java是一种强类型语言，每个变量都必须声明其数据类型。 Java的数据类型可分为两大类：基本数据类型（```primitive data type```）和引用数据类型（```reference data type```）。

Java中定义了3类8种基本数据类型

• 数值型－ byte、 short、int、 long、float、 double
• 字符型－ char
• 布尔型－boolean

方法的重载(overload)

​ 方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

雷区

​ 重载的方法，实际是完全不同的方法，只是名称相同而已!

​ 构成方法重载的条件：

1. 不同的含义：形参类型、形参个数、形参顺序不同
2. 只有返回值不同不构成方法的重载
3. 只有形参的名称不同，不构成方法的重载

代码实例

public class Test21 {
    public static void main(String[] args) {
        System.out.println(add(3, 5));// 8
        System.out.println(add(3, 5, 10));// 18
        System.out.println(add(3.0, 5));// 8.0
        System.out.println(add(3, 5.0));// 8.0
        // 我们已经见过的方法的重载
        System.out.println();// 0个参数
        System.out.println(1);// 参数是1个int
        System.out.println(3.0);// 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

面向对象的内存分析

​ Java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area。

栈的特点如下：

1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)

2. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息(实际参数、局部变量等)

3. 栈属于线程私有，不能实现线程间的共享!

4. 栈的存储特性是“先进后出，后进先出”

5. 栈是由系统自动分配，速度快!栈是一个连续的内存空间!

堆的特点如下：

1. 堆用于存储创建好的对象和数组(数组也是对象)

2. JVM只有一个堆，被所有线程共享

3. 堆是一个不连续的内存空间，分配灵活，速度慢!

方法区(又叫静态区)特点如下：

1. JVM只有一个方法区，被所有线程共享!

2. 方法区实际也是堆，只是用于存储类、常量相关的信息!

3. 用来存放程序中永远是不变或唯一的内容。(类信息【Class对象】、静态变量、字符串常量等)

垃圾回收原理和算法

内存管理

Java的内存管理很大程度指的就是对象的管理，其中包括对象空间的分配和释放。

对象空间的分配：使用new关键字创建对象即可

对象空间的释放：将对象赋值null即可。垃圾回收器将负责回收所有”不可达”对象的内存空间。

垃圾回收过程

任何一种垃圾回收算法一般要做两件基本事情：

1. 发现无用的对象

2. 回收无用对象占用的内存空间。

垃圾回收机制保证可以将“无用的对象”进行回收。无用的对象指的就是没有任何变量引用该对象。Java的垃圾回收器通过相关算法发现无用对象，并进行清除和整理。

垃圾回收相关算法

引用计数法

堆中每个对象都有一个引用计数。被引用一次，计数加1. 被引用变量值变为null，则计数减1，直到计数为0，则表示变成无用对象。优点是算法简单，缺点是循环引用的无用对象无法别识别。

循环引用示例

public class Student {
    String name;
    Student friend;
     
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
         
        s1.friend = s2;
        s2.friend = s1;        
        s1 = null;
        s2 = null;
    }
}

s1和s2互相引用对方，导致他们引用计数不为0，但是实际已经无用，但无法被识别。

引用可达法(根搜索算法)

程序把所有的引用关系看作一张图，从一个节点GC ROOT开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点，即无用的节点。

通用的分代垃圾回收机制

​ 分代垃圾回收机制，是基于这样一个事实：不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的回收算法，以便提高回收效率。我们将对象分为三种状态：年轻代、年老代、持久代。JVM将堆内存划分为Eden、Survivor 和 Tenured/Old 空间。

年轻代

所有新生成的对象首先都是放在Eden区。 年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象，对应的是Minor GC，每次 Minor GC 会清理年轻代的内存，算法采用效率较高的复制算法，频繁的操作，但是会浪费内存空间。当“年轻代”区域存放满对象后，就将对象存放到年老代区域。

年老代

在年轻代中经历了N(默认15)次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。年老代对象越来越多，我们就需要启动Major GC和Full GC(全量回收)，来一次大扫除，全面清理年轻代区域和年老代区域。

持久代

用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响。

• Minor GC:

用于清理年轻代区域。Eden区满了就会触发一次Minor GC。清理无用对象，将有用对象复制到Survivor1、Survivor2区中(这两个区，大小空间也相同，同一时刻Survivor1和Survivor2只有一个在用，一个为空)

• Major GC：

用于清理老年代区域。

• Full GC：

用于清理年轻代、年老代区域。 成本较高，会对系统性能产生影响。

垃圾回收过程

1、新创建的对象，绝大多数都会存储在Eden中，

2、当Eden满了（达到一定比例）不能创建新对象，则触发垃圾回收（GC），将无用对象清理掉，

​ 然后剩余对象复制到某个Survivor中，如S1，同时清空Eden区

3、当Eden区再次满了，会将S1中的不能清空的对象存到另外一个Survivor中，如S2，

​ 同时将Eden区中的不能清空的对象，也复制到S1中，保证Eden和S1，均被清空。

4、重复多次(默认15次)Survivor中没有被清理的对象，则会复制到老年代Old(Tenured)区中，

5、当Old区满了，则会触发一个一次完整地垃圾回收（FullGC），之前新生代的垃圾回收称为（minorGC）

开发中容易造成内存泄露的操作

创建大量无用对象

​ 比如，我们在需要大量拼接字符串时，使用了String而不是StringBuilder

静态集合类的使用

​ 像HashMap、Vector、List等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，所有的对象Object也不能被释放。

种连接对象(IO流对象、数据库连接对象、网络连接对象)未关闭

​ IO流对象、数据库连接对象、网络连接对象等连接对象属于物理连接，和硬盘或者网络连接，不使用的时候一定要关闭

监听器的使用

​ 释放对象时，没有删除相应的监听器。

要点

1. 程序员无权调用垃圾回收器。
2. 程序员可以调用System.gc()，该方法只是通知JVM，并不是运行垃圾回收器。尽量少用，会申请启动Full GC，成本高，影响系统性能。
3. finalize方法，是Java提供给程序员用来释放对象或资源的方法，但是尽量少用。

封装的实现—使用访问控制符

• private 表示私有，只有自己类能访问
• default表示没有修饰符修饰，只有同一个包的类能访问
• protected表示可以被同一个包的类以及其他包中的子类访问
• public表示可以被该项目的所有包中的所有类访问

修饰符	同一个类中	同一个包中	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

多态(polymorphism)

• 多态是方法的多态，不是属性的多态(多态与属性无关)

• 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

• 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

• class Animal {
      public void shout() {
          System.out.println("叫了一声！");
      }
  }
  class Dog extends Animal {
      public void shout() {
          System.out.println("旺旺旺！");
      }
      public void seeDoor() {
          System.out.println("看门中....");
      }
  }
  class Cat extends Animal {
      public void shout() {
          System.out.println("喵喵喵喵！");
      }
  }
  public class TestPolym {
      public static void main(String[] args) {
          Animal a1 = new Cat(); // 向上可以自动转型
          //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
          animalCry(a1);
          Animal a2 = new Dog();
          animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
           
          //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
          // 否则通不过编译器的检查。
          Dog dog = (Dog)a2;//向下需要强制类型转换
          dog.seeDoor();
      }
   
      // 有了多态，只需要让增加的这个类继承Animal类就可以了。
      static void animalCry(Animal a) {
          a.shout();
      }
   
      /* 如果没有多态，我们这里需要写很多重载的方法。
       * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
      static void animalCry(Dog d) {
          d.shout();
      }
      static void animalCry(Cat c) {
          c.shout();
      }*/
  }
  

  输出结果

  喵喵喵喵！
  旺旺旺！
  看门中....
  

  ​ 多态的主要优势是提高了代码的可扩展性，符合开闭原则。但是多态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用Dog类特有的seeDoor()方法

对象的转型(casting)

1. 父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换
2. 向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!
3. 在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型)否则会出现类型转换异常ClassCastException

ClassCastException异常

public class TestCasting2 {
    public static void main(String[] args) {
        Object obj = new String("北京");
        //真实的子类类型是String，但是此处向下转型为StringBuffer
        StringBuffer str = (StringBuffer) obj;
        System.out.println(str.charAt(0));
    }
}

  为了避免出现这种异常，我们可以使用```instanceof```运算符进行判断

public class TestCasting3 {
    public static void main(String[] args) {
        Object obj = new String("北京");
        if(obj instanceof String){
            String str = (String)obj;
            System.out.println(str.charAt(0));
        }else if(obj instanceof StringBuffer){
            StringBuffer str = (StringBuffer) obj;
            System.out.println(str.charAt(0));
        }
    }
}

final关键字

1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。
2. 修饰方法：该方法不可被子类重写。但是可以被重载!
3. 修饰类: 修饰的类不能被继承。比如：Math、String等

final  int   MAX_SPEED = 120;
final  void  study(){}
final   class  A {}

抽象方法和抽象类

抽象方法

使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

抽象类

包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

/抽象类
abstract class Animal {
    abstract public void shout();  //抽象方法
}
class Dog extends Animal { 
    //子类必须实现父类的抽象方法，否则编译错误
    public void shout() {
        System.out.println("汪汪汪！");
    }
    public void seeDoor(){
        System.out.println("看门中....");
    }
}
//测试抽象类
public class TestAbstractClass {
    public static void main(String[] args) {
        Dog a = new Dog();
        a.shout();
        a.seeDoor();
    }
}

抽象类的使用要点

• 有抽象方法的类只能定义成抽象类
• 抽象类不能实例化，即不能用new来实例化抽象类。
• 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
• 抽象类只能用来被继承。
• 抽象方法必须被子类实现。

接口的作用

为什么需要接口?接口和抽象类的区别

​ 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

​ 抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。

​ 从接口的实现者角度看，接口定义了可以向外部提供的服务。

​ 从接口的调用者角度看，接口定义了实现者能提供那些服务。

​ 接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

​ 接口和实现类不是父子关系，是实现规则的关系。比如：我定义一个接口Runnable，Car实现它就能在地上跑，Train实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现Runnable接口。

接口的本质探讨

​ 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须能干掉坏人;如果你是坏人，则必须欺负好人。

​ 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

​ 面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如C++、Java、C#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

区别

1. 普通类：具体实现
2. 具体实现，规范(抽象方法)
3. 接口：规范!

定义和使用接口

声明格式

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
常量定义；  
方法定义；
}

定义接口的详细说明

1. 访问修饰符：只能是public或默认。

2. 接口名：和类名采用相同命名机制。

3. extends：接口可以多继承。

4. 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。

5. 方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。

要点

1. 子类通过implements来实现接口中的规范。

2. 接口不能创建实例，但是可用于声明引用变量类型。

3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

4. JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。

5. JDK1.8后，接口中包含普通的静态方法。

public class TestInterface {
    public static void main(String[] args) {
        Volant volant = new Angel();
        volant.fly();
        System.out.println(Volant.FLY_HIGHT);
         
        Honest honest = new GoodMan();
        honest.helpOther();
    }
}
/**飞行接口*/
interface Volant { 
    int FLY_HIGHT = 100;  // 总是：public static final类型的；
    void fly();   //总是：public abstract void fly();
}
/**善良接口*/
interface Honest { 
    void helpOther();
}
/**Angle类实现飞行接口和善良接口*/
class Angel implements Volant, Honest{
    public void fly() {
        System.out.println("我是天使，飞起来啦！");
    }
    public void helpOther() {
        System.out.println("扶老奶奶过马路！");
    }
}
class GoodMan implements Honest {
   public void helpOther() {
        System.out.println("扶老奶奶过马路！");
    }  
}
class BirdMan implements Volant {
    public void fly() {
        System.out.println("我是鸟人，正在飞！");
    }
}

接口的多继承

​ 接口完全支持多继承。和类的继承类似，子接口扩展某个父接口，将会获得父接口中所定义的一切。

interface A {
    void testa();
}
interface B {
    void testb();
}
/**接口可以多继承：接口C继承接口A和B*/
interface C extends A, B {
    void testc();
}
public class Test implements C {
    public void testc() {
    }
    public void testa() {
    }
    public void testb() {
    }
}

资料合集

https://pan.baidu.com/s/1hfShuXEGrGnhkRikv2sZfQ
提取码：nqy2