JAVA基础
一. Java的历史
Java诞生于1995年，创始人为大胡子gosling，后来给甲骨文公司收购。
二. Java概述
2.1 Java的重要特点
- Java是面向对象的（oop）
- Java是健壮的，有强类型机制、异常处理、垃圾的自动收集等
- Java是跨平台的，生成的class文件可以在各个系统平台运行（基于Java虚拟机JVM）
- Java是解释性的（解释性语言编译生成的文件还需要经过一个解释器来运行，而像C/C++是编译性语言，生成的二进制文件可以直接给机器执行）
2.2 JDK.JRE.JVM介绍
- JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令,管理数据、内存、寄存器，包含在JDK中
JDK>JRE>JVM - JDK=JRE+开发工具集
- JRE=JVM+Java SE标准类库（Java核心类库）如果只想运行开发好的 .class 文件 只需要JRE
2.3配置环境变量path
2.4快速入门
javac hello.java //编译hello.java文件
java hello //运行Java类
//tab补全类
//第一个Java程序
public class hello{//公共类
public static void main(String[] args){//main函数是程序入口
System.out.println("hello world!");
}
}
//文件有中文时，->设置文件编码->GBK(常用为UTF-8
2.5 JAVA注意事项
- hello.java 是源文件，hello.class是字节码文件
- Java程序的应用入口是main()方法，他有固定的书写格式
- Java严格区分大小写。
- Java方法由一条条语句构成，每个语句以";"结束。{}都是成对出现的。
- 一个源文件中最多只有一个public类，其他类的个数不限。
- 如果源文件包含一个public类，则文件名必须和该类名一致。
- 可以把main方法写在非public类中，然后指定运行该类，这样程序的入口就是非public类的main方法。因为在编译后，一个类对应一个class文件。
2.6 JAVA学习方法
如何快速学习技术或者知识点？
明确需求：工作需要？入职要求？解题需要？技术控？
看看是否能够用传统的技术解决？能解决但是不完美，或者解决不了。
引出需要学习的新技术或者知识点（明确目标）。
学习新技术或者知识点的基本原理和基本语法（不考虑细节，掌握基础，为建知识大厦做准备）。
快速入门：写一个基本程序，实现基本功能如增删查改。
研究技术的注意事项，注意使用细节和规范，细究优化，永无止境。
2.7 转义字符
\t：一个制表位，实现对齐的功能
\n：换行符
\\：一个\
\"：一个"
\'：一个'
\r：一个回车，光标返回本行首位 (同一行的最前面)
char c03 = '\r';
//光标移到前面 "c03 = " + '1' + c03 +'2'); 输出为203 = 1
2.8 注释
1）单行注释 //
2）多行注释 /* */
3）文档注释 /** /
/*
*
*/
Java生成文档注释以网页形式：
javadoc -d 文件名 -xx -yy Demo3.java
javadoc -d 文件名 -author -version comments.java
2.9 Java代码规范
- 类、方法的注释，要以javadoc的方式来写。
- 非Javadoc的注释，往往是给代码的维护者看的，着重告诉读者为什么这样写，如何修改，注重什么问题。
- --使用tab操作，实现整体往右缩进，shift+tab整体往左缩进。--
- 运算符(+-= etc)两边习惯加一个空格。
- 源文件使用utf-8编码。
- 行宽度不超过80。
- 代码编写遵循行尾风格，大括号前一个紧跟在实例后面，后一个另起一行的行头。
2.10 常用的dos命令
1）查看当前目录是有什么内容 dir
2）切换到其他盘下 : 盘符号 cd : change directory eg：切换到c盘 cd /D c:
3）切换到当前盘的其他目录下(使用相对路径和绝对路径演示)，..\表示上一级目录
4）切换到上一级: cd ..
5）切换到根目录: cd
6）查看指定的目录下所有的子级目录 tree
7）清屏 cls
8）退出 DOS exit
原理：接受命令->解析命令->执行命令。
相对路径：从当前目录开始寻找需要的文件的位置。
绝对路径：从根目录开始寻找需要的文件的位置。
配置环境变量有什么用？ 为了Dos系统在任何位置都可以使用Java命令。
Java的编写步骤 1.编写Java源代码 2. 通过Javac编译得到.class的字节码文件 3. 使用Java运行，将字节码文件在jvm中运行
2.数据类型
-
强类型语言
-
弱类型语言: js ,vb
-
基本类型
- 数值类型
- 整数：byte，short,int,long；1，2，4，8
- 浮点数:float,double4，8
- 字符:char；2
- 布尔类型:true和false；占一个位
- 数值类型
public class Demo01 {
public static void main(String[] args) {
//八大数据类型
//整数
int num1 = 10;
byte num2 = 20;//-128<num2<127
short num3 = 30;
long num4 = 30;//Long类型在数字后面加L
//小数：浮点数
float num5 = 50.1F;//float类型要在数字后面加个F
double num6 = 3.1415926;
//字符
char name = '过';//char 只能写一个
//字符串，String不是关键字，属于类
//String namea = “芳芳”;
//布尔值：是与非
boolean flag = true;
//boolean flag = false;
}
}
数据类型拓展
public class Demo03 {
public static void main(String[] args) {
//整数拓展 ：进制 二进制0b 十进制 八进制0 十六进制 0x
int i = 10;
int i2 = 010;//八进制0
int i3 = 0x10;//十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("=====================");
//============================================================
//浮点数扩展？银行业务怎么表示？ 钱
//BigDecimal 数学工具类
//=============================================
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
float f = 0.1f;//0.1
double d = 1.0 / 10;//0.1
System.out.println(f == d);//false
float d1 = 231312334534f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true
//============================================================
//字符扩展？
//=============================================
char c1 = 'a';
char c2 = '中';
//底层原理
System.out.println(c1);
System.out.println((int) c1);//强制转换
System.out.println(c2);
System.out.println((int) c2);
//所有字符本质还是数字
//编码Unicode表：(97 = a 65 = A) 2字节 0-65536 Excel 2^16 = 65536
//U0000 UFFFF
char c3 = '\u0061';
System.out.println(c3);//a
//转义字符
//\t 制表符
//\n 换行
//....
System.out.println("Hello\tWord");
System.out.println("=====================");
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa==sb);//false
String sc = "hello word";
String sd = "hello word";
System.out.println(sc == sd);//true
//对象 从内存分析
//布尔值扩展
boolean flag = true;
if (flag == true) {}//新手
if (flag) {}
//Less is More 代码要精简易读
}
}
3. 类型转换
4.变量、常量
5.运算符
6.包机制、JavaDoc
Java流程控制
1、用户交互Scanner
Scanner对象
通过Scanner类的next()和nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
java.util.Scanner
//基础用法
Scanner s = new Scanner(system.in);
//hasnext的用法
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("用next方式接收");
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用next方式接收
String str = scanner.next();
System.out.println("输出内容为:"+str);
}
//凡是属于IO流的类如果不关掉会一直占用资源，要养成良好习惯
scanner.close();
}
}
//hasnextline
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("用next方式接收");
if(scanner.hasNextLine()){
//使用next方式接收
String str = scanner.nextLine();//程序会等待用户输入完毕
System.out.println("输入内容："+str);
}
//凡是属于io流的类如果不关闭会一直占用资源，用完就要关闭
scanner.close();
}
}
/**
*nextline的使用方法不用判断
*/
public class Demo03 {
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据");
String str = scanner.nextLine();
System.out.println("输入内容："+str);
//凡是属于io流的类如果不关闭会一直占用资源，用完就要关闭
scanner.close();
}
}
//输入多个数字，并求其总和与平均数，每日输入一个数字用回车确定，通过输入非数字来结束并输出执行结果；
public class Demo05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double sum = 0;
//计算输入多少个数字
int i =0;
//通过循环判断是否还有输入，并在循环里每一次进行求和和统计
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
i = i + 1;//m++
sum = sum + x;
}
System.out.println(i +"个数的和为"+ sum);
System.out.println(i + "个数的平均值是"+(sum/i));
scanner.close();
}
}
Ctrl 点击类：可查看方法
2、顺序结构
顺序结构是最基本的结构
3、选择结构
- if单选择结构
if(布尔表达式){
//表达式为true则执行
}
- if双选择结构
if(布尔表达式){
//表达式为true则执行
}else{
//如果布尔表达式为false
}
- if多选择结构
- if语句至多有一个else语句。else在所有的else if之后
- if语句可以有多个else if语句，必须在else之前
- 一旦其中一个else if检测为true，其他的else if 以及else 都将跳过执行
if(布尔表达式1){
//表达式1为true则执行
}else if(布尔表达式2){
//表达式2为true则执行
}else if(布尔表达式3){
//表达式3为true则执行
}
else{
//如果以上布尔表达式为false
}
- if嵌套结构
if(布尔表达式1){
//如果布尔表达式1的值为true执行代码
if(布尔表达式2){
//如果布尔表达式2的值为true执行代码
}
}
- switch多选择结构
- switch case语句
--case没有写break有穿透现象
--switch 匹配一个具体的值
- switch case语句
switch(expession){
case value:
//语句
bleak;//可选
case value:
//语句
bleak;//可选
//可以有任何数量的语句
default://可选
//语句
}
// switch在javase7开始支持string
4、循环结构
- while循环
避免死循环
while(布尔表达式){
//循环内容
}
//需要一个表达式失效来结束循环
- do...while循环
- 如果至少
do{
//代码语句
}while(布尔表达式)
- While和do-while的区别
while先判断后执行，dowhile是先执行后判断
do....while至少执行一次 - for循环： 最有效最灵活的循环结构
for(初始化；布尔表达式；更新){
//代码语句
}
//最开始执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后检测布尔表达式的值。如果为true，循环体被执行，如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新控制变量（迭代因子控制变量的增减）。再次检测布尔表达式。循环执行上述过程
- Java5引入了一种主要用于数组和集合的增强型for循环
for(声明语句：表达式)
{
//代码句子
}
//声明语句：声明新的局部变量
//表达式：表达式要访问的数组名
5、break&continue
- break用于强行退出循环
- continue用于终止某次循环过程，即跳过循环体尚未执行的语句
- break与continue的不同
break强行退出循环，不执行循环剩余语句
continue跳过循环体中尚未执行的语句，，接着进行下一次是否执行循环判定
- break与continue的不同
- 关于goto关键字
java没有goto带标签的break和continue
6、test
打印三角形
for
for
for
java方法
1、何谓方法：函数，是一段完成特定功能的代码片段
System.out.println()
类.对象.方法
//包含一个方法头和方法体
修饰符 返回类型 方法名（参数类型 参数名）{
方法体
return 返回值；
}
- 方法是语句的集合
- 命名规范：首字母小写按照驼峰书写规范
- 参数：形参和实际参数
2、方法的定义及调用:java都是值传递
- 调用方法：对象名.方法名（实参列表）
- Java支持两种调用方法
- 方法返回一个值时，方法调用通常被当作一个值
int larger = mac(30,40);
- 方法返回值为void，方法调用一定是一条语句
System.out.println("hello!")
值传递和引用传递
3、方法的重载
- 方法名称相同
- 参数列表必须不同
- 返回类型可相同可不同
- 仅仅返回类型不同不足以成为方法重载
4、命令行传参
5、可变参数
6、递归
A方法自己调用自己
主要包括递归头和递归体
数组
1、数组概述
- 数组是相同类型的有序集合
- 先后次序
- 每个数组元素通过下标来访问他们
2、数组声明创建
dataType[] arrayRefVar;
使用new操作符创建数组
dataType[] arrayRefVar = new dataType[arraySize];
- 数组索引从0开始
- 获取数组长度：arrays.length =
java.lang.ArrayIndexOutOfBoundsException 数组下标越界
数组的基本特点
- 长度是确定的
- 元素必须是相同类型
- 可以是任何数据类型：基本类型和引用类型
- 数组也是对象，数组元素相当于成员变量
3、数组使用
- For-Each
- 数组作为方法入参
- 数组作返回值
4、多维数组
djfjh
5、Arrays类
打印数组元素：Arrays.toString
对数组进行排序主要为升序：Arrays.sort
public static void printArray(int[] a){
for (int i = 0; i < a.length ; i++){
if( i==0){
System.out.print("[");
}
if(i==a.length-1){
System.out.print(a[i]+"]");
}else {
System.out.print(a[i]+",");
}
}
6、稀疏数组
- 当一个数组大部分元素为0，或为同一值的数组时，可以使用稀疏数组来保存该数组
- 把具有不同值的元素和行列及值记录在小规模的数组中
- 6行7列8个数值
第0行第3列值为22
//array1.for：输出下方ints
for (int[] ints : array1) {
//ints.for
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
面向对象
1、初识
面向过程（具象）&&面向对象(抽象)
- 线性思维；分类的思维
- 宏观面向对象，微观面向过程
本质：以类的方式组织代码，以对象的方式组织（封装）数据
抽象： 编程思想 持续学习！
三大特性
- 封装
- 继承：
- 多态：同一个事物不同种形式
先有对象后有类（认识论）--> 现有类后有对象，类是对象的模板（教书-->老师）
2、方法回顾加深
方法的定义
- 修饰符
- 返回类型
- break：跳出switch，结束循环 和return的区别
- 方法名：注意规范；见名知意
- 参数列表：（参数类型，参数名） ...
- 异常抛出：？？
方法的调用：递归
- 静态方法
public class Demo02 {
public static void main(String[] args) {
//student.say()静态方法可直接调取
//实例化这个类 new
//对象类型 对象名 = 对象值；
Student student = new Student();
student.say();
}
}
public class Student {
//public static say()静态
public void say(){
System.out.println("学生说话");
}
}
- 非静态方法
//和类一起加载的
public static void a(){
b();
}
//类实例化 之后才存在
public void b(){
}
- 形参和实参
//法一
public class Demo03 {
public static void main(String[] args) {
---> <-------
new Demo03().add(1,3);
}
public int add(int a,int b){
return a+b;
}
}
//法二
public class Demo03 {
public static void main(String[] args) {
Demo03.add(1,3);
}
public static int add(int a,int b){
return a+b;
}
}
```
- 值传递和引用传递
```java
package Icy.oop;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);//1
Demo04.change(a);
System.out.println(a);//1
}
public static void change(int a){
a = 10;
}
}
package Icy.oop;
//引用传递：对象，本质还是值传递
public class Demo05 {
public static void main(String[] args){
Person person = new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);
}
public static void change(Person person){
//person是个对象：指向的 ---> Person person = new Person();这是个具体的人，可以改变属性
person.name = "阿拉玛";
}
}
//定义了一个Person类，有一个属性：name
class Person{
String name;//null
}
- this关键字
3、对象的创建分析
1. 创建初始化对象
-
使用new关键字创建对象
-
创建类中的构造器==构造方法
特点
1. 必须与类名相同
2. 必须没有返回值
作用
1. 使用new关键字，本质是调用构造器
2.用来初始化对象的值
注意点
1. 定义有参构造之后，如果想用无参构造，必须定义一个无参构造 -
创建对象内存分析
小结
- 类与对象
类是一个模板：抽象，对象是一个具体实例 - 方法
定义，调用 - 对应的引用
引用类型：基本类型（8种）
对象是通过引用来操作的：栈（引用）--->堆（new） - 属性：字段field 成员变量
默认初始化：
数字：0 0.0
char：u0000
Boolean：false
引用：null
修饰符 属性类型 属性名 = 属性值
5.对象的创建和使用
- 必须使用new 关键字创建对象，构造器Person person = new Person();
- 对象的属性 person.name
- 对象的方法 person.sleep()
6.类：
静态属性 属性
动态行为 方法
4、面向对象三大特性
1. 封装：高内聚，低耦合
属性私有：get/set 属性私有private
package demo04;
public class Student {
private String name;
private int id;
private char sex;
private int age;
//提供一些public的 get set 方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age < 0 || age > 120){//大于121，小于0
this.age = 3;
} else {
this.age = age;
}
}
}
//import demo04.Student;
///*
// * 1. 提高代码的安全性，保护数据
// * 2. 隐藏代码实现细节
// * 3.统一接口
// * 4.系统可维护增加
// * */
//public class Application {
// public static void main(String[] args) {
// Student s1 = new Student();
// s1.setName("zhangsan");
// System.out.println(s1.getName());
// s1.setAge(121);
// System.out.println(s1.getAge());
//
// }
//}
2. 继承
-
2.1extends 子类是父类的扩展
-
2.2 继承是类与类之间的关系，类只有单继承
-
2.3所有类，都默认直接或间接继承object类
super vs this
调用父类vs 调用自己
super注意点：
1.super();//调用父类的构造器必须在子类构造器的第一行
2.super 和 this不能同时调用构造方法
super vs this
代表的对象不同：
this 本身调用这个对象
super 代表父类对象的应用
前提
this 没有继承也能使用
super 只能在继承条件才可以使用
构造方法
this();本类的构造
super()父类的构造
重写 @Override（子类重写父类）
重写都是方法的重写跟属性无关
静态方法和非静态方法的区别很大===静态方法：方法调用只和左边相关
重写：需要又继承关系，子类重写父类的方法
1. 方法名必须相同
2. 参数列表必须相同
3.修饰符：范围可以扩大但不能缩小 public > protected > default > private
4. 抛出异常：范围可以缩小但不能扩大 ClassNotFoundException --> Exception
重写，子类的方法和父类的必须一致，但方法体不同
3. 多态
多态注意事项
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 没联系会出现类型转换异常ClassCastException
3.存在条件 继承关系方法需要重写，父类引用指向子类对象 Father f1 = new Son();
不能使用多态：
- static 方法，属于类，不属于实例
- final 常量,就无法继承了
- private方法
instance of
//Object >Person > student
//Object > String
//Object > Person > Teacher
Object obj = new Student();
System.out.println(obj instanceof Student);
System.out.println(obj instanceof Person);
System.out.println(obj instanceof Teacher);
System.out.println(obj instanceof String);
// System.out.println(Person instanceof String);编译报错
- 把子类转化为父类，向上转型
- 把父类转化成子类，向下转型 强转
Static
package demo07;
public class Person {
//2
{
System.out.println("代码块(匿名代码块)");//代码块(匿名代码块)
}
//1
static{//与类一起执行永久只执行一次
System.out.println("静态代码块");
}
//3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person p1 = new Person();
System.out.println("==============");
Person p2 = new Person();
}
}
5、抽象类和接口
抽象类: 具体实现和规范（抽象方法）abstract
package demo08;
//abstract 抽象类： extends是单继承(但接口可以多继承)
public abstract class Action {
//进行制约，子类实现方法
//abstract 只有方法名字，没有方法实现
public Action() {
}
public abstract void dosomething();
//1.不能new这个抽象类，只能靠子类去实现，约束
//2. 抽象类可以写普通方法
//3.抽象方法必须在抽象类中
//抽象的抽象：约束
public void hello(){
}
//不能new 存在构造器嘛，存在
//存在的意义是提高开发效率
}
```
###接口：只有规范，专业的约束，约束和实现分离 interface
1. 进行约束
2.定义一些方法，让不同的人实现
3. 默认的方法都是public abstract
4.常量 public static final
5. 接口不能被实例化，接口中没有构造方法
6. implement 可以实现多个接口
7.必须重写接口中的方法
8.总结博客
##6、内部类以及opp实战
内部类就是在一个类内部再定义一个类
```java
package demo10;
public class Outer {
private int id = 12;
public void out(){
System.out.println("这是外部类");
}
public class Inner{
class method{
//局部内部类
}
public void in(){
System.out.println("这是内部类");
}
//能获得外部类的私有属性
public void getId(){
System.out.println(id);
}
}
//一个java类中可以有多个class类，但只能有一个public class
class A{
}
}
Application.java
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
7. 异常
1. 异常
Exception
检查性异常
运行时异常
错误
2.异常体系结构
java.lang.Throwable
Error 由Java虚拟机生成抛出
Error时程序无法控制和处理的，exception是可以被程序处理的
3. Java异常处理机制
抛出异常
捕获异常
异常处理五个关键字
- try catch、finally、throw、 throws
4. 处理异常
package exception;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//要捕获多个异常，要从小到大
try {//try监控区域
if (b == 0){//throw throws
throw new ArithmeticException();//主动抛出异常
}
new Test().a();
}catch (Error e) {//捕获异常
System.out.println("Error");
}catch (Exception e){
System.out.println("Exception");
}catch (Throwable e){
System.out.println("Throwable");
} finally {
System.out.println("finally");
}//finally 可以不要，但设置I/O的时候需要资源关闭
}
public void a(){b();}
public void b(){a();}
}
主动抛出
package exception;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//要捕获多个异常，要从小到大
try {//try监控区域
new Test().Test(1,0);
}catch (ArithmeticException e) {//捕获异常
System.out.println("Error");
}
}
//方法中主动抛出是throw ，处理不了，在方法上抛出异常throws
public void Test(int a,int b)throws ArithmeticException{
if (b == 0){//throw throws
throw new ArithmeticException();//主动抛出异常
}
}
}
5. 自定义异常
package exception.demo02;
//自定义异常
public class MyException extends Exception{
//数字大于10
private int detail;
//构造器
public MyException(int a){
detail=a;
}
//toString
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
test.java
package exception.demo02;
public class Test {
static void test(int a) throws MyException{
if (a > 10){
throw new MyException(a);//抛出
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
System.out.println("exception => " + e);
}
}
}
- 总结
浙公网安备 33010602011771号