Java 基础

Write Once ，Run Anywhere（JVM）

java的特性

简单性，面向对象，可移植性，高性能，分布式，动态性，多线程，安全性，健壮性。

java的三大版本

JavaSE：标准版本（桌面程序，控制台开发） JavaME：嵌入式开发 JavaEE：E企业级开发（Web端，服务器开发）

一些概念

JDK：Java Development Kit – Java开发环境 JRE：Java Runtime Environment – Java运行环境 JVM：Java Virtual Machine – Java虚拟机

MAC OS Java开发环境安装

下载安装：教程 安装好后的路径：

检查：java -version

编译：javac hello.java 会生成hello.class文件 运行：java hello.java

Java程序运行机制

编译型：全部翻译 解释型：一次编译一次 JAVA是两种结合 源程序(.java)—>Java编译器—>字节码(.class)—>JVM—>解释器—>操作系统

Java 文件夹的解释

JAVA

注释

单行注释：// 多行注释：/* / 文档注释：/* @Description */ 中间添加的参数是有意义的

标识符与关键字

关键字：例如abstract，byte，int，public等等

标识符：标识符是大小写敏感的，Java是强类型语言

数据类型

强类型语言：（速度慢，比较安全）要求变量的使用严格符合规定，所有的变量必须先定义后使用

弱类型语言：

Java数据类型：

基本类型：数值类型整数类型 byte 1个字节short 2个字节 int 4个字节long 8个字节 long num4 = 30L; long 类型需要在数字后面加F 浮点类型float 4个字节 float num5 = 50.1F; double 8个字节 字符类型char 2个字节 boolean类型（占1位，其值只有True & False）引用类型：reference type类接口数组

注意：String是一个类

数据类型拓展

Q1:整数拓展 A1:二进制0b 十进制 八进制0 十六进制 0x

int i = 10; int i2 = 010; int i3 = 01; int i4 = 0x10;

Q2:浮点数拓展 A2:最好完全使用浮点数进行比较，注意false与true

float f = 0.1f; double d = 1.0/10; System.out.println(f==d);false float d1 = 321323132323213123f; double d2 = d1+1; System.out.println(d1==d2);true

Q3:字符拓展 A3:所有的字符本质还是数字 编码问题Unicode编码 表 97 = a 2个字节 0-65536

char c1 = "a"; System.out.println(c1); System.out.println(int(c1));强制类型转换

Q4:转义字符 A4:\t \n

System.out.println("hello \n world");

Q5:new A5:

String c1 = new String("hello world"); String c2 = new String("hello world"); System.out.println(c1==c2);false String c3 = "hello world"; String c4 = "hello world"; System.out.println(c3==c4);true

Q6:布尔值拓展 A6:

boolean flag = true; if (flag == true){} if (flag){}

类型转换

运算中，不同类型的数据类型需要先转化成为相同的数据类型，然后再进行运算。

低---------------------------------------------->高 byte ,short, char -> int -> long -> float -> double

转换的时候，注意内存溢出的问题，或者出现内存溢出的问题。 不能对布尔值进行转换。

int i = 128; byte b = (byte)i; 强制类型转换(高->低)自动类型转换（低->高）

操作比较大的数字的时候，要注意内存的溢出问题。 JDK7新特性，数字之间可以用下划线区分

int money = 10_0000_0000; int years = 20; int total = money*years;//内存溢出 long total = long(money*years);//内存同样溢出 long total = money*((long)years);

变量，常量，作用域

变量作用域

类变量（前面要加static）从属于这个类，同存亡实例变量 （从属于对象，如果不初始化，这个类型的默认值 布尔值默认为flase，除了基本类型其余的都是null）局部变量 public class Variable{ static int allClicks = 0; //类变量 String str = "hello world"; // 实例变量 public void method(){ int i = 0;//局部变量 } public static void main(String[] args){ } }

常量

public class demo{ //修饰符不区分前后顺序 static final double PI = 3.14; final static double Pi = 3.14; public static void main(String[] args){ System.out.println(PI) } }

基本运算符

算数运算符 + - * / % ++ –赋值运算符 =关系运算符 > < >= <= == !=instanceof逻辑运算符 && || !位运算 & | ^ ~ >> << >>>条件运算符 ?:拓展赋值运算符 += -= *= /=

自增自减运算符，初识Math类

a++; ++a; Math.pow(2,3);

逻辑运算符，位运算符

boolean a = true; boolean b = false; a&&b; a||b; ~b; //短路运算 b&&a //b已经是假了，不会执行后面的a操作 int c = 5; boolean b = (c<4)&&(c++<4); System.out.println(b);false System.out.println(c);//5，没有进行++运算 //如果+有字符串和数字注意转换 int a = 10; int b = 20; System.out.println(" "+ a + b);// "1020" string System.out.println(a+b+"");//30 int //三元运算符 x?y:z int score = 80; String type = score < 60 ?"no":"yes";

要注意优先级,多用()

包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。

包语句的语法格式为

package pkg1[.pkg2[]]

一般利用公司域名倒置作为包名

Java Doc生成文档

javadoc 命令是用来自己生成API文档的参数信息@author 作者名 @version 版本号@since 指明需要最早使用的jdk版本@param 参数名@return 返回值情况@throws 异常抛出情况

流程控制

Scanner

用户交互Scanner对象

next:一定要读取到有效字符后才可以结束输入 对于输入有效字符之前遇到的空白，next()方法会将其去掉next()不能得到带有空格的字符串 nextLine():以Enter为结束符 可以获得空白 package Demo2; import java.util.Scanner; public class demo1 { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("使用next方式接收"); //判断用户是否输入字符串 String str = scan.next(); //String str = scan.nextLine(); System.out.println("输出的内容为："+str); //凡是io流的类，要把这玩意关掉 scan.close(); } }

Scnner进阶

判断

顺序结构

if选择结构

Switch选择结构

While循环

DoWhile循环

For循环

print:输出完毕后不会换行 println:输出完毕后会换行

增强For循环

break continue goto

breakbreak在任何循环语句中的主体部分，均可使用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句continue用于终止某次的循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定goto

方法

在同一个class中调用该class下的方法的时候，需要在方法前面加一个新的static修饰符。表示属于类变量

实际参数 形式参数

什么是值传递，什么是引用传递。java是值传递

方法的重载

重载就是在一个类中，有着相同的函数名称，但是形式参数不同

方法名称必须相同参数列表必须不同（个数不同，或者类型不同，参数排列顺序不同）方法的返回类型可以相同也可以不同但是仅仅是方法的返回类型不同则不足以构成方法的重载。

实现理论：方法名称相同的时候，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果全部匹配失效，则编译器会报错。

命令行传递参数

有时候你希望运行一个程序时候再传递给它消息，这需要靠传递命令行参数给main()函数实现。

public class CommandLine { public static void main(String[] args) { for(int i = 0;i<args.length;i++){ System.out.println("args["+i+"]"+args[i]); } } }

可变参数

在jdk1.5开始，Java支持传递同类型的可变参数在方法声明中，在指定参数类型后加一个省略号（…）一个方法只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它之前声明 public class printMax { public static void print(double... numbers){ if (numbers.length == 0){ System.out.println("No numbers in the params"); return; } double result = numbers[0]; for (int i =1;i<numbers.length;i++){ if (numbers[i] >result){ result = numbers[i]; } } System.out.println("The max value is \t"+result); } public static void main(String[] args) { print(1,2,3,4,5,6,7,8,9); } }

递归

注意边界条件 java都是使用栈机制的

public class rec { public static int f(int n){ if (n==1) return 1; return n*f(n-1); } public static void main(String[] args) { System.out.println(f(5)); } }

数组

Java 内存分析

Java内存堆： 存放new的对象以及数组可以被所有的线程共享，不会存放别的对象引用栈存放基本变量类型（会包含这个基本类型的具体数值） 引用对象的变量（会存放这个引用在堆里面的具体地址） 方法区可以被所有的线程共享 包含了所有class和static变量

数组的声明与创建

三种初始化及内存分析

静态初始化 创建➕赋值 int[] a = {1,2,3}; Man[] mans = {new man(1,1),new man(2,2)} 动态初始化（包含了默认初始化） int[] a = new int[2]; a[0] = 1; a[1] = 2; 数组的默认初始化 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每一个元素也被按照实例变量同样的方式被隐式初始化。

稀疏数组

面向对象编程 OOP

注意break与return的区别；

面向对象编程的本质就是：以类的方式组织代码，以对象的方法组织（封装）数据。

方法

静态方法 static 可以直接通过类名调用方法名进行方法的调用动态方法（非静态方法）必须实例化这个类，然后再进行方法的调用。

静态方法不能调用非静态方法

静态方法是和类一起加载的，时间片特别早，不是静态方法只有类进行了实例化之后才会存在。

public class Demo02 { public static void main(String[] args) { //若是静态方法 Student.say(); //若不是静态方法 /* Student student = new Student(); student.say(); */ } }

形式参数与实际参数

值传递与引用传递

this关键字

创建与初始化对象

使用new关键字创建对象使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用 类中的构造器也称之为构造方法，是在进行创建的时候必须要调用的，并且构造器有以下两个特点：必须和类的名字相同 必须没有返回类型，并且不能写void

创建对象内存分析：

有一个Pet类，Main方法创建了一个pet对象，然后调用了shout()方法

首先会将Application类加载到方法区中，main()方法也会加载到栈中，然后执行到创建Pet对象的时候，将Pet类也加载到方法区，然后创建的dog变量，其中dog引用变量名称会存放在栈中，然后这个dog引用对象指向堆中的一块内存空间，这块空间中保存了自己创造的dog变量的一些自己创建的信息。然后创建的信息指向静态方法区，其中静态方法区的static声明的变量就会和类一起加载。

简单小结类与对象：

对象是通过引用来操作的：就上面的图而言，就是栈中的引用然后指向堆中的实例变量。栈指向地址 。

抽象

面向对象的三大特性：

封装高内聚，低耦合，属性私有，get/set继承继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模 extends的意思是拓展，子类是父类的拓展JAVA中类只有单继承，没有多继承继承是类和类之间的一种的关系。除此之外，类和类之间的关系还有依赖，组合，聚合继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。子类和父类之间，从意义上讲应该具有"is a"的关系。object类,在Java中，所有的类，都默认直接活着间接继承Object extends Objectsuper （和this进行对比）调用父类的构造方法，必须在构造方法的第一个 super必须只能出现在子类的方法活着构造方法中super和this不能同时调用构造方法VS this代表的对象不同 this本身调用者对象super代表父类的引用前提this：没有继承也可以调用 super：只能有继承条件才可以调用 构造方法this（）；本类的构造 super（）：父类的构造 方法重写 （重点—>多态）@Override 重写：有功能的注释 方法名称必须相同参数列表必须相同修饰符，番位可以扩大但是不能缩小：public > Protected>Default>private抛出的异常：范围可以被缩小但是不能扩大：ClassNoteFoundException–>Exception（大）为什么需要重写父类的功能，子类不一定需要 多态动态编译：类型：可拓展性 即同一方法可以根据发送对象的不同而采用不同的行为方式一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多多态存在的条件有继承关系 子类重写父类的方法父类引用指向子类你对象 注意：多态是方法的多态，属性没有多态 instanceof 类型转换 判断一个对象是什么类型 System.out.print(object instanceof Student);同级类型下是不能够用instanceof进行判断的级别：OBject>(String,Person,Student)

static修饰符

package Demo5; public class static_test { //匿名代码块 { System.out.println("匿名代码块"); } // 静态代码块 static { System.out.println("静态代码块"); } public static_test(){ System.out.println("构造方法"); } public static void main(String[] args) { static_test st = new static_test(); System.out.println("######################"); static_test st2 = new static_test(); } }

抽象类

abstract 抽象类的所有方法，继承了他的子类，都必须要实现他的方法，（接口） 抽象类不能new，只能靠子类去实现它，是一种约束。 抽象类中可以写普通的方法。 抽象方法必须在抽象类中。

public abstract class Action { public abstract void something(); } public class A extends Action{ @Override public void something() { } }

接口

普通类：只有具体实现抽象类：具体实现和规范都有接口：只有规范 约束与实现分离

声明类的关键字是class，声明接口的关键字是interface

类extends 单继承 接口可以多继承

接口的定义与实现

内部类

内部类就是在一个类的内部定义类

成员内部类静态内部类局部内部类匿名内部类

异常机制

什么是异常

简单分类

检查性异常运行时异常错误

异常体系结构

Java把异常当作对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类 在JavaAPI中已经定义了许多异常类，这些异常类分为两大类，错误ERROR和异常Exception

Java异常处理机制

抛出异常捕获异常异常处理5个关键字try,catch,finally,throw,throws

处理异常

自定义异常

总结