Java基础——————（1）

1. Java 概述

1.1 Java发展史

　　1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；

　　1994年将Oak语言更名为Java；

        2009年Oracle收购Sun;

---

1.2 Java的三种技术架构:

　　JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；

　　JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；

　　JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；

---

1.3 JDK (Java Development Kit)

        JDK：Java Development Kit：java的开发和运行环境，包括java的开发工具和jre。

　　JRE：Java Runtime Environment：java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

       JVM: Java Virtual Machine: 就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行,但只有JVM还不能成class的执行

(19条消息) 浅谈JDK、JRE、JVM区别与联系_Αиcíеиτеǎг的博客-CSDN博客_jdk jre jvm 的区别和联系

---

 1.4 JDK安装和使用命令行工具

(19条消息、、) JDK的下载、安装和环境配置教程（2021年，win10）_「已注销」的博客-CSDN博客_jdk这里为了简化命令的使用户需要提前配置环境变量

常用DOS命令

注：编写好的java的源文件 文件名.java ;  编译好的文件名 .class

public class HelloWorld {                                                                //类名大写

 public static void main(String[] args){

          System.out.println("Hello World");

   } 

}                                                                                            //注意文件名应该与类名相同

$进入到含HelloWorld.java的目录中

$ javac HelloWorld.java                                                       //编译源文件，生成类文件

$ java HelloWorld                                                                //运行类文件

javac命令和java命令做什么事情呢？

　　　java是分两部分的：一个是编译，一个是运行。

　　javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。

　　java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数.

---

 2. Java 的基本程序设计结构

2.1 简单的Java应用程序

public class FirstSample{
    public static void main(String[] args){
        ....;
    }
}

1.public 是访问修饰符 代表访问级别（还有protected private）
2.类(class)是构建Java应用程序的构建块
3.类名必须为字母开头，后可跟字母数字组合，且类名以大写字母开头，最好驼峰命名法；源代码文件名应该与类名同
4.类中必须包含main方法，且main必须为public
5.Java区分大小写

---

2.2 注释

注释：（不参与编译）

//单行注释

/*多行注释*/

/*** 这个类绘制一个条形图

* @author runoob

* @version 1.2 */

---

2.3 常量与变量

常量就是值不变的值，变量是用来存储的值

变量声明注意：

        1.变量名一般为字母开头，并由字母、数字、_、$组成

        2.变量申明后需要显式的赋值再使用

        3.变量声明尽量靠近第一次需要使用的地方

        4.嵌套结果中不要重复声明同一变量

习惯上常量用大写表示，注意空常量不能输出

//声明常量
final int A_FINAL =1;   int可替换为其他的值
//类常量
public static final int A_FINAL  = 1; 声明在main方法外

---

 2.4 基本数据类

Java是强类型语言必须声明类型，但Java10开始对于局部变量如可从初值推断则用var也可

内置数据类型（8种 4整+2浮+1字符+1布尔） 

• .变量定义注意：1.不可重复定义变量名，2.变量未赋值，有些情况不能使用

float a=123.4f/F, double=2.3D/d, long a=100000L, boolean one =true/false, char a=’A’

char类型存原表示存单个字符，但如今有些Unicode用一个char,有些用2个

整数类型与布尔值不可以转换

类型转换：（小转大，大转小需要强制转换）

虚线箭头表示可能会产生精度的损失

//注意：对于浮点型数据存储并不精确，解决方法，导入decimal
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.1'));

强制转换

float a = 2.1f;
int b = (int)a;

当用二元运算符连接变量时的转换规则（向上转）

两个数值进行二元操作时，要先将两个操作数转换为同一种类型，然后再进行计算。

        如果两个操作数中有一个是double类型，另一个操作数就会转换成double类型。

        否则，如果两个操作数中有一个是float类型，另一个操作数就会转换成float类型。

        否则，如果两个操作数中有一个是long类型，另一个操作数就会转换成long类型。

        否则，两个操作数都将转换成int类型。

---

2.5 运算符

算术运算符

        +、-、*、/、%、++、--

注意：1.整数被0除，抛出异常；浮点数被0除会得到无穷大或者NaN

           2.自加在变量前先加1再操作，在变量后先操作再+，--同

           3.在不同数据类型进行算术运算时，基本数据类型会自动升级。但在String中‘+’作连接

赋值运算符

       =、+=、-=、*=、/=、%=                                         

 注意：扩展的赋值运算符隐含强制转换

关系运算符

       ==、!=、>、<、>=、<=

位运算符

      &、|、^、！、<<、>>

注意：1.可以按位进行计算，也可作为逻辑运算符使用

           2.>>>左移时用0填充高位，无<<<

逻辑运算符                                                                       /

     &&、||、！

注意：1.与上的区别在于短路

条件运算符(三元运算符)

     a=1;

    Int b = （a==1）? 20:30;

• 注意：+在字符,字符串中也可以用到

int i = 10;
char c = 'c';
int u = i+c;//这里输出的为65

//字符串中'+'作为拼接，连续+操作时，从左到右
System.out.println("it"+"a");//输出为ita
System.out.println(222+"a");//输出为222a
System.out.println('a'+66+6);//a666
System.out.println(1+99+'a');//100a

1. instanceof运算符检查该对象是否是一个特定类型（类类型或接口类型）

String name = "James";boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真   

---

2.6 输入与输出

     1.标准输出输入

import java.util.Scanner;
class TestScanner{
    public ststic void main(String[] args[]){
        //创建Scanner对象
        Scanner s = new Scanner(System.in);
        int name=s.next();
    }
}

• • .输入的类型：

    next();              //以空格为分隔符                                nextInt()    //读取整数

    nextLine();      //读取一行，可包含空格                       nextDouble() //读取浮点型

  s.hasNext() //检测是否还有其他的单词 ，返回boolean   hasNextInt/Double()

  //输出
  System.out.println() /print()
  //格式化输出,同c
  System.out.printf("%d &s %c %f /n",intvar,Stringvar,charvar,floatdouvar);

控制台输入（适合用来输入密码）

Console con=System.console();
String username= con.readLine("Write your name");
char[] passwd=con.readPassword("Password:");

---

2.7 流程控制与循环

1.if

if(布尔表达式) {                                                   //如果表达式为一条，可以去掉{}

                  //如果布尔表达式为true将执行的语句

 }

2.If...else                                                            //无括号的esle与邻近if配对

if(布尔表达式){   //如果布尔表达式的值为true

  }else{               //如果布尔表达式的值为false 

}

3.If...else if ...else

if(布尔表达式 1){                //如果布尔表达式 1的值为true执行代码

}else if(布尔表达式 2){           //如果布尔表达式 2的值为true执行代码

}else {

   //如果以上布尔表达式都不为true执行代码}

4.switch...case

switch(expression){

 case value : //语句 break; //可选

default : //可选 //语句 }

1.while

while( 布尔表达式 ) { //循环内容 } 

2.do...while                        //与前不同的是该处至少执行一次

do { //代码语句}while(布尔表达式);

3.for

for(初始化; 布尔表达式; 更新) { //代码语句 }

for(声明语句：表达式){//代码语句}//int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ){...}

4.break和continue

break 跳出最里层的循环,break可与标签连用

continue 作用是让程序立刻跳转到下一次循环的迭代。

---

 2.8 数组（存储相同类型值的序列）

数组的定义格式：1. int[] num = new num[20];//动态初始化,一旦创建，就无法更改值其长度

                             2.int[] num = {1,2,3};//静态初始化

                             3. num = new int[]{1,2,3}; //匿名数组

注意：允许长度为0的数组，0!=null

          数组创建时都有初值，int为0，boolean为false,对象为null

数组访问：num[索引]       //索引从0开始,.索引越界抛出异常

数组长度：num.length

数组拷贝

      当数组拷贝到另外一个数组时，实际是两个变量引用同一个数组即两变量指向同一个地址，所以能对其值进行改变

      如果需要拷贝值则需要调用Array类的copyOf()方法

int[] A = {1,2,3};
System.out.println(A); %输出的是A的地址
int[] B = Array.copyOf(A,A.length);

多维数组

//声明
int [][] balance=new int[10][2];
int[][] balance={                        //可以构造不规则的数组
                  {1,2,3}
                 ,{2,1};
                };
//使用foreach访问
for(int[] row: balance){
    for(int num: row){

       System.out.println(row);
    }
}

常用的Array方法

int[] A={1,2,3,13,4,5};
String sA=Array.toString(A);      //toString()将数组转换为字符串
int[] rA=Array.copyOf(A,A.length);//copyOf()复制数组的值
Array.sort(A);                    //快速排序
int Anum=Array.binarySearch(A,2) //binary的前提是数组有序，且返回的是下标
Array.equal(A,rA);               //比较两个数组的值

包装类：java.lang.Byte/.../Char（用于与String类型转换）

最小值：Byte/.../Char.MIN_VALUE

最大值：Byte/.../Char.MAX_VALUE

二进制位数：Byte/.../Char.SIZE

1.1.2对象和类（抽象，继承，封装，多态）

public class Dog { //类名称

//类属性

String name; int age; String color; //成员变量: 定义在类中，方法体之外的变量

//类变量， 静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。

private static double salary;

//构造方法：每个类都有构造函数，没创造即为系统隐式分配,一个类可以有多个构造函数但是调用时只调用一个

public Dog(){ } 

public Dog(String name){ // 这个构造器仅有一个参数：name }

//方法：可在方法前加public,private,project

void barking(){ int a;}//局部变量： 在方法、构造方法或者语句块中定义的变量被称为局部变量

void sleeping(){ System.out.println(“sleeping”); }

public static void main(String[] args){ 

// 实例化Dog对象

  Dog  myDog = new Dog( "tommy" );

myDog.sleeping();//访问类中的变量

myDog.name;//访问类中的属性

}

 }

1.1.3基本数据类

 1.内置数据类型

基本数据类型:byte,short,int,float a=123.4f,double,long a=100000L,boolean one =true/false,char a=’A’

 变量定义注意：1.不可重复定义变量名，2.变量未赋值，有些情况不能使用

包装类：java.lang.Byte/.../Char（用于与String类型转换）

最小值：Byte/.../Char.MIN_VALUE

最大值：Byte/.../Char.MAX_VALUE

二进制位数：Byte/.../Char.SIZE

• .引用数据类型(引用类型指向一个对象)

 对象，数组都是引用数据类型，其默认值为nul

•  常量（在运行时不可以被修改）

用关键词final修饰，通常使用大写字母表示常量

final double PI = 3.1415927;

类型转换：（小转大，大转小需要强制转换）

byte,short,char—> int —> long—> float —> double （自动类型转换）

//注意：对于浮点型数据存储并不精确，解决方法，导入decimal
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.1'));

强制转换

float a = 2.1f;
int b = (int)a;

1.1.4修饰符

1,访问修饰符

default:在同一包内，不使用任何修饰符 使用对象：类、接口、变量、方法

private：在同一类可见，使用对象：变量、方法，不可修饰类

public:对所有类可见，使用对象：类、接口、变量、方法

protected:对同一包内类和子类可见。使用对象：变量、方法，不可修饰类

访问控制和继承：父public子也必须public，父protected子public/protected

2.非访问修饰符

static：修饰类方法和类变量(静态类中只可以使用静态方法)

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。（声明 final 方法的主要目的是防止该方法的内容被修改。）

abstract 修饰符，用来创建抽象类和抽象方法。（如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。）

synchronized 和 volatile 修饰符，主要用于线程的编程。

1.1.5运算符

算术运算符

    +、-、*、/、%、++、--

关系运算符

==、！=、>、<、>=、<=

位运算符

    &、|、^、~

逻辑运算符                                                                      //与上的区别在于短路

&&、||、！

赋值运算符

=、+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=       //扩展的赋值运算符隐含强制转换

条件运算符

a=1;

Int b = a==1? 20:30;

• 注意：+在字符,字符串中也可以用到

int i = 10;
char c = 'c';
int u = i+c;//这里输出的为65

 

//字符串中'+'作为拼接，连续+操作时，从左到右
System.out.println("it"+"a");//输出为ita
System.out.println(222+"a");//输出为222a
System.out.println('a'+66+6);//a666
System.out.println(1+99+'a');//100a

1. instanceof运算符检查该对象是否是一个特定类型（类类型或接口类型）

String name = "James";boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真   

1.1.6循环结构

1.1.7流程控制

1.1.8数组 

数组的定义格式：1. int[] num = new num[20];//动态初始化

                             2.int[] num = {1,2,3};//静态初始化

数组访问：num[索引]//索引从0开始

数组长度：num.length

数组内存分配：数组在初始化时，会自动为其分配初始值

数组常见小问题：1.索引越界 2.空指针异常（空值为null，与其不同）

 1.1.9 方法

方法格式：public static 返回值类型 方法名（形参）{   

//方法体

return 数据；

}

调用：方法名（实参值）；

注意事项：1.方法不能嵌套2.当返回类型为void 可写return;也可不写

方法重载：同一个类中定义了方法名相同，但参数不同，即类型不同，数量不同，与返回值无关

public class Test7 {
    public static void main(String[] args) {
        int a=0,b=2,c=4;
        plus(a,b);
        plus(a,b,c);
    }
    public static int plus(int a,int b){        //注意重载只与参数有关
        int sum = a + b;
        return sum;
    }
    public static int plus(int a,int b,int c){
        int sum = a + b + c;
        return sum;
    }
}

1.1.9包装类

  包装类主要提供了两大类方法：

1. 将本类型和其他基本类型进行转换的方法

2. 将字符串和本类型及包装类互相转换的方法

（1）装箱（基本数据类型->包装类）

int i = 0; Integer j =  Integer.valueOf(i)//手动装包 

Integer k = i//自动装包

（2）拆箱 （包装类->基本数据类型）

Integer i = lnteger.valueOf(6);

int j = i.intValue();//手动解析

int k = i;//自动解析

1. Number类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类，Number 类属于 java.lang 包

                                     

Integer y = Integer.valueOf(5);//定义Integer包装类，值为5

                             

1.基本类型和字符串之间的转化

基本类型转字符串：int i = 8;

    String str1 = Integer.toString(i);

     String str2 = String.valueOf(i);

字符串转基本类型：String a =”8”;

      int a = Integer.parseInt(a);

      int b = Integer.valueOf(a);  

1. Character类(Character 类在对象中包装一个基本类型 char 的值)

      Character ch = new Character('a');  //装箱拆箱同上

      方法

     Character.isLetter('c') Character.isDigit(1);Character.isWhitespace(‘’);

     Character.isUpperCase(‘A’);Character.isLowerCase(‘a’);

     Character.toUpperCase(‘a’); Character.toLowerCase(‘A’);

                  Character.toString('a')

1. String类（一旦创建了 String 对象，那它的值就无法改变了，每次 new 一个字符串就是产生一个新的对象）

1.创建String类

String str1=”hello world”; String str2=new Stirng(“sagfsd”);

2.即便两个字符串的内容相同，使用 ”==” （==在字符串中此时比较的是地址是否相同）比较时也为 ”false” ,如  果只需比较内容是否相同，应使用 ”equals()” 方法。

str1.equals(str2);

3.字符串常用操作

str1.length();str1.concat(str2);str1.charAt(1);//e str1.compareTo(str2); str1.indexOf(‘l’);//2

str1.indexOf(‘l’,3);//从第三个位置开始查 str1.replace('o', 'T');str1.replaceAll(‘o’,’T’);

String str =”1-2-3-4”; str.split(“-”,2)//结果1 2-3-4 以-为分隔符，分隔成两份

str.isEmpty();

System.out.printf/format("浮点型变量的值为 " + "%f, 整型变量的值为 " + " %d, 字符串变量的值 为 " + "is %s", floatVar, intVar, stringVar)//创建格式化字符串

1. StringBuffer和StringBuilder类（当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类）

区别：

1. 其最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
2. StringBuilder 相较于 StringBuffer 有速度优势，多数情况下使用 StringBuilder 类。
3. 在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类

1.创建

StringBuffer sbf1 = ”Hello”; StringBuilder = “World”;

2. 方法

  sbf1.append(“Bala”);//增加 sbf1.reverse();//翻转 sbf1.delete(0,1)//移除0-1的字符

  sbf1.insert(2,1);//将在第3个位置插入1 sbf1.repalce(0,1,”he”);//从第0个位置插入“he”直到1

1. Date类和SimpleDateFormat（需要引入import java.util.Date,需要引入import java.text.SimpleDateFormat）

3.方法

Date day1 = new Date(); day1.getTime();//返回自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。

day1.after(day2);//调用此方法的Date对象在指定日期之后返回true

day1.before(day2);//调用此方法的Date对象在指定日期之前返回true

day1.compareTo(day2);//比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。

Thread.sleep(1000*3); // 休眠3秒  sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用

注意：调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理（import java.text.ParseException）

1.1.9常用API

(以下部分方法为static)

1.Math类及其常用方法：

1.Math.abs(-1);     Math.floor(1.5);//下取整             Math.ceil(1.5);//上取整

 2.Math.round(5.5);            Math.max(2,3);        Math.min(1,3);          Math.exp(11.635);                Math.random();

2.System类

1.System.ext(0);         //终止java虚拟机，终止程序 ,非0则为异常终止

2.System.currentTimeMillis()        //从1960到现在的毫秒

3.Object类

1.toString   //所有的类均将继承Object类，按下ALT+ENTER自动生成重写的toString()方法

2.equal        //比较的是对象的地址，按下ALT+ENTER自动生成重写的方法

4.Arrays类

1.Arrays.sort(a);            //排序

2.Arrays.toString(a)        //拼接数组为string 类型

5.Date类

1. Date d1=new Day();     //生成时间对象

2.long date = 1000* 60 *60;       Date  d2 = new Date（date）；  //分配一个date对象，并以做基准自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。

3.Date day1 = new Date();   day1.getTime();//返回从现在自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。

4.long date = 1000* 60 *60;     day1.setTime();//设置自 1970 年 1 月 1 日 00:00:00 GMT 以后的毫秒数。

6.SimpleDateFormat类

Date now = new Date();

1.日期转文本

SimpleDateFormat s =new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);   //无参为默认格式

String today =s.format(now);//格式转换方法一 日期转文本

2.文本转日期

String today=”2020年2月5日 22:33:20”；

SimpleDateFormat s = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);

 Date d =s.parse(today);   //ALT+ENTER

 

7.Calender类   (抽象类)

8.Random类

Random r = new Random();
int num = r.nextInt(10);