Java基础

一、基础概念。

Java分为三个体系：

• JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
• JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
• JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

一次编译多处运行。

JRE：Java 运行环境               JVM：Java 虚拟机        IDE：Eclipse、NetBeans 等

JVM(跨平台的核心) —> JRE —> JDK (开发工具包)

Java 运行过程：· 如Hello.java （类名和文件名一致）

1、编译： Javac 将源文件(如Hello.java)  ——>(编译)  class 字节码文件

2、解释：Java  Hello   运行时，JVM即时编译，将字节码文件转换成机器码。java后不要加.class

$ javac HelloWorld.java
$ java HelloWorld
Hello World

public class HelloWorld {
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

    结构顺序：
        1、package test;           #对类和接口分类
        2、import xxx;               #声明引用
        3、class Hello() { }        #类定义

二、变量

！！大小写敏感

        类名：首字母大写,与文件名一致， Hello.java
        方法名：小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
        源文件名：与类名相同，文件名后缀.java     

   
        声明：对象名及类型
        实例化： new --> 创建对象
        初始化： new对象时，调用构造函数
        
        局部变量：声明/初始化均在方法中
        类变量/静态变量：类中，方法外，声明为 static
        成员变量：非静态，已实例化

        局部变量：
            类C：不能用访问修饰符于局部变量；在栈上分配；没有默认值，即未初始化会报错。
            生存期：方法执行时创建，执行后销毁
            作用域：定义变量的方法中
        实例变量：
            即成员变量，可以加访问修饰符，有默认值。
            生存期：对象创建到对象销毁
        类变量：
            静态变量->静态存储区
            生存期：第一次访问时创建，程序结束时销毁
        Java 数组 —> 存储在堆上的对象

---

   装箱： 基本数据类型 —> 包装器类型   （编译器处理）
   拆箱： 包装器类型 —> 基本数据类型

        8种内置数据类型：

内置数据类型	大小	包装类
boolean	True/False	Boolean
byte	8bit	Byte
char	16bit	Character
short	16bit	Short
int	32bit	Integer
float	32bit	Float
double	64bit	Double
long	64bit	Long

        注意 char        16bit，区别于C语言，\u0000~\uffff (65535),16进制unicode       
        引用类型：指向对象的变量->引用变量，如对象、数组： Site site = new Site("hello")
        

        Character类：
            Char ch='a';
            Character ch = new Character('a');#默认构造方法创建对象
            方法：isLetter()、isDigitl()、isWhitespace()、toString()等。
        String类(不可改变)：
            String s1 = "Run";//直接创建，公共池
            String s2 = s1;  //引用，公共池
            String s3 = new String("Run"); //对象创建，堆
        String创建的字符串在公共池；
        String创建的对象在堆上。
        *不可改变：String内部实际存储——> char, value被final修饰。

#多维数组
    String s[][] = new String[2][]
    s[0] = new String[2]; //分配2列
    s[1] = new String[3]; //分配3列，一行2列，一行3列，不必定对齐。
    s[0][0] = new String("Good");

  

String s1 = new String("Java");
String s2 = "Java";
s1.equals(s2); //False

 StringBuilder: 速度快，但不是线程安全的，一般使用这个。
    StringBuffer：线程安全，要求线程安全时使用，
                StringBuilder sb = new StringBuilder(10);
                sb.append("Run");
                sb.insert(2,"java");
                sb.delete(1);
            方法：append、reverse、delete、insert、replace
    数组：在堆上分配
            doublep[] mList;
            dataType[] ar = new dataType[10]; 

      常量：final 修饰，final double PI = 3.1415926

---

        访问修饰符：
        1、default   默认，同一包内可见          类、接口、方法、变量 均可
        2、private   同一类内可见                   方法、变量-可， 类-否
        3、public    所有类可见，不同包可见     类、接口、方法、变量 均可
        4、protected 同一包内的类和所有子类可见 方法、变量-可， 类-否
        

	当前类	同包	子类	其他包
public	可	可	可	可
protected	可	可	可	否
default	可	可	否	否
private	可	否	否	否

        default:  接口里变量隐式声明 public static final
                  接口里方法默认  public
        private:  隐藏类的实现细节和保护类的数据
        
      protected: 需要确定protected成员来自何方；确定其可见性范围。
          1、子类与基类在同一包中： 被protected修饰的变量/方法/构造器 能被同一包中任何类访问（不需要继承关系）
          2、子类与基类不在同一包中：子类实例可以访问继承而来的protected方法，不能访问基类实例的protected方法。 

Package P1;
class father{
    protected void fun(){}
    }

Package P2;
public class Son extends father{
    public static void main(Strings[] args){
    father fob = new father();
    fob.fun();  #失败，不能访问基类实例的protected方法

    Son sob = new Son();
    sob.fun();  #成功，子类实例可以访问继承的protected方法
    }}

        继承规则：1、父类 public 方法    ——> 子类中必须为public
                          2、父类 protected 方法 ——> 子类 public/protected 不可以private
                          3、父类 private 方法   ——> 子类不能继承
                    *总结，父类 ——> 子类，权限不能变小。

---

    非访问修饰符：
        static:  类方法/类变量；静态方法不能使用类的非静态变量。访问方式通过类，而不是实例！
        final:   修饰类(不可继承)、修饰方法(不能被继承类重新定义,即不可重写)、变量(常量)；安全高效
        abstract:抽象类/抽象方法(为了后续对该类进行扩充)，通过子类继承去实现。
        synchronized：声明的方法同一时间只能被一个线程访问(单例模式)
        voatile：修饰的成员变量，每次被线程访问时，从共享内存中读取成员变量值(主动行为，不会自动同步)；值改变也会写入共享内存。保证多线程访问时，成员变量值一致。

        Arrays类
            方法：fill、sort、equals、binarySearch(二分查找)
        可变参数：
            fun(int ... num){}
        finalize 方法：对象销毁前执行(protected修饰)
            手动回收:需要重写系统自动回收的方法—— System.gc();//Java的垃圾收集器

---

        增强for循环：
            int num={10,20,30,40,50}
            for(int x: num){}

---

Java异常： java.lang.Exception
            检测性异常
            运行时异常
            错误
            
        自定义异常：
            1、必须是Throwable的子类
            2、检测性异常——> 继承Exception类
            3、运行时异常——> 继承Runtime Exception类

---

OOP：封装、继承、多态、抽象

1、继承：
            单继承， java.lang.object
            public class c extends A,B{}      ——> 不能继承多个类
            public class c implements A,B{}  ——> 可实现多个接口
            super ——> 实现对父类成员的访问

构造器：
            ！！子类不继承父类的构造器
            super ——> 实现对父类成员的访问
            父类构造器带参数 ——> 子类super调用父类构造器
            父类构造器无参数 ——> 子类不用super，自动调用父类构造器

2、多态 — 重写&重载：
        重写 Override：涉及继承
            子类重写父类允许访问的方法，
            外壳不变，核心重写：返回值和形参不能变
            *子类抛出异常不能比父类抛出的异常更宽泛
            如，父类 IO Exception，子类只能 IO Exception或者其子类。
            
        重载 Overload
            同一类里：方法名字相同，返回值类型、修饰符和参数可以不同
            ——常用于构造器重载。

        重写：运行时的多态性
        重载：编译时的多态性
            继承、重写，父类引用指向子类对象： Animal a = new Cat();

3、抽象：
            抽象类：不能实例化对象，需要子类继承实现
            一个类只能继承一个抽象类
            一个类可以实现多个接口
            抽象方法： public abstract double computePay();  //!!!没有方法体。
            接口：抽象方法的集合， 成员变量 ——> public static final 类型

4、封装：访问控制符控制

---

类型通配符
            public static void getData(List<?> data){};
            List<String> name = new ArrayList<String>();
            name.add("icon");

---

JVM 有哪些分区：

JVM是一个内存中的虚拟机，那它的存储就是内存了，我们写的所有类、常量、变量、方法都在内存中，因此明白java虚拟机的内存分配非常重要，本部分主要讲解java虚拟机内存分配。

1、方法区(method)：被所有的线程共享。方法区包含所有的类信息和静态变量。

2、堆(heap)：被所有的线程共享，存放对象实例以及数组，Java堆是GC的主要区域。

3、栈(stack)：每个线程含一个栈区，栈中保存一些局部变量等。

4、程序计数器：是当前线程执行的字节码的行指示器。

public class SimpleHeap {
    private int id;

    public SimpleHeap(int id) {
        this.id = id;
    }

    public static void main(String[] args) {
        SimpleHeap s1 = new SimpleHeap(1);
        SimpleHeap s2 = new SimpleHeap(2);
        s1.show();
        s2.show();
    }

    public void show() {
        System.out.println("my id is" + id);
    }
}

---

 

 

Java实现线程的方法：

1、继承Thread类，重写run函数。

2、实现Runable接口，重写run函数。

3、实现Callable接口，重写call函数。