Java 基础

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

• break
• break在任何循环语句中的主体部分，均可使用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 Object
  • super （和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

处理异常

自定义异常

总结