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