关于java:JavaSE学习笔记第一部分

本篇次要是本人学习 Javase 的笔记，参考 B 站视频课程 https://www.bilibili.com/vide…

第一章：Java 语言概述

1.1 根底常识

• 罕用 dos 命令：

dir: 列出当前目录下的文件以及文件夹
md: 创立目录
rd: 删除目录
cd: 进入指定目录
cd..: 退回到上一级目录
cd: 退回到根目录
del: 删除文件
exit: 推出 dos 命令行

1.2Java 语言的个性

• Java 语言的个性：面向对象，健壮性和欠缺性，跨平台性（一次编写，处处运行，Java 虚拟机）。
• 面向对象：把形成问题事务分解成各个对象，建设对象的目标不是为了实现一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
• 面向过程：就是剖析出解决问题的步骤，而后用函数把这些过程一步一步的实现，应用的时候一个一个调用就能够了。
• 面向对象可能更好的在形象的层面来剖析问题，在程序实现上能够极大的复用之前的代码，这些是面向过程编程很难实现的。
• Java 语言是一个纯正的面向对象的程序设计语言，它继承了 c ++ 面向对象技术的外围。Java 舍弃了 C 语言中容易引起谬误的指针（以援用取代），运算符重载，多重继承（以接口取代）等个性，减少了垃圾回收机制用于回收不再被援用的对象所占据的内存空间。jdk1.5 又引入了泛型编程，类型平安的枚举，不定长参数和主动拆装箱。
• Java 技术体系平台：

  Java SE: 标准版（J2SE），提供了残缺的 Java 外围 API
  Java EE: 企业版（J2EE），次要针对 web 利用开发
  Java ME: 小型版
  Java Card：反对一些 Java 小程序

1.3Java 语言运行机制及运行过程

Java 的两种外围机制：

• JVM：Java 虚拟机。JVM 是一个虚构的计算机，具备指令集，并应用不同的存储区域。负责执行指令，治理数据、内存、寄存器。对于不同的平台，有不同的虚拟机。Java 虚拟机机制屏蔽了底层运行平台的差异，实现了“一次编译，到处运行”。

• GC：垃圾回收机制：

c，c++ 内存回收 由程序员手动编写代码回收，长处是：可能在内存不应用时及时回收，精确高效。毛病是：容易失误产生 bug，例如：遗记编写回收内存的代码，进而使得内存始终不回收，产生内存透露。

Java 垃圾回收是主动的，开了一个零碎级的线程主动去检测哪些内存不应用了须要回收。长处是：主动的回收，意味着不会遗记回收；毛病是：回收不及时。个别的观点是：宁肯回收不及时但肯定要回收。应用主动的垃圾回收机制更为适合不便。

1.4jdk，jvm，jre 之间的关系

JDK：Java 开发工具包。

• JDK 是提供给 Java 开发人员应用的，其中蕴含了 Java 的开发工具，Java 的外围 API，也包含了 jre。其中的开发工具有：编译工具（javac.exe），打包工具（jar.exe）等。

jre：是 Java 运行环境。

• 包含 Java 虚拟机和 Java 程序所须要的外围类库。如果只是须要运行 Java 程序，则只须要装置 jre 即可。

关系：JDK 蕴含 JRE 蕴含 JVM。

1.5 第一个 Java 程序 helloworld

步骤：

1. Java 程序编写在 .java 文件中；
2. 通过 javac 命令对 Java 文件进行编译；
3. 通过 java 命令对生成的 class 文件进行运行。

public class HelloWorld{

public static void main(){System.out.println("hello world");
}

}

1.6 正文

用于注解阐明解释程序的文字就是正文。

进步了代码的浏览性；调试程序的重要办法。

Java 正文分类：

• 单行正文：//
• 多行正文：/ /
• 文档正文：/* /Java 特有。

第二章：Java 根本语法 1

2.1 关键字

• 定义：被 Java 语言赋予看非凡含意，用作专门用处的字符串（单词）。
• 特点：关键字中所有字母都为小写。
• eg：int,long,class,interface,enum,byte,true,false,if,null 等

Java 保留字：现有 Java 版本尚未应用，当前版本可能会作为关键字应用，本人命名标识符时要留神避开这些保留字。byValue,cast,future,generic,inner,operator,outer,rest,var,goto,const

2.2 标识符

标识符：Java 对各种变量，办法和类等因素命名时应用的字符序列称为标识符。但凡能够本人起名字的中央都叫标识符。

规定：

• 由 26 个英文字母大小写，数字 0 -9，_或者 $ 组成
• 数字不能够结尾
• 不能够独自应用关键字和保留字，但能蕴含关键字和保留字。
• Java 中严格辨别大小写，长度无限度。
• 标识符不能蕴含空格。
• 留神：在起名字时，为了进步浏览性，要尽量有意义，“见名知意”。

Java 中的命名标准

• 包名：多单词组成时，所有单词字母都小写；例如：xxxyyyzzz。
• 类名、接口名：多单词组成时，所有单词首字母大写。XxxYyyZzz。
• 变量名、办法名：多单词组成时，第一个单词的首字母小写，第二个单词开始首字母大写；xxxYyyZzz。
• 常量名：所有字母都大写。多个单词时，每个单词之间应用下划线隔开：XXX_YYY_ZZZ。
• 命名标准是约定俗称的。

2.3 变量的概念与定义

概念：

• 内存中的一个存储区域；
• 该区域有本人的名称和类型也就是变量名和变量的数据类型；
• Java 中的每个变量必须先申明，后应用；
• 该区域的数据能够在同一类型范畴内一直变动（变量的值能够扭转）。
• 定义变量的格局：数据类型 变量名 = 变量的值;

应用变量时留神：

• 变量的作用域：在一对 {} 之间无效。
• 初始化值。

变量是通过变量名来拜访这块区域的。

2.4 数据类型

2.4.1 根本数据类型

整数类型：

定义 long 类型的变量赋值的时候要在值的前面加上“l”或者‘’L‘。

浮点类型：

Java 中浮点类型默认是 double，申明 float 类型时，前面须要加'f','F'

字符类型：

字符：用英文的单引号括起来的单个的字母、数字、符号；比方：char c1 = 'a';char c2 = '2';char c3 = '*';

转义字符：

布尔类型：

boolean 类型数据只容许取值 true 或者 false，没有 null；

• 留神：不能用 0 或者非 0 的整数代替 false 和 true，这点和 c 不一样。

2.4.2 援用数据类型

String 类

• 值 null 能够赋值给任何援用类型 (类、接口、数组) 的变量，用以示意这个援用类型变量中保留的地址为空。
•  String 类属于援用类型，可用 nulI 赋值。
• String 类是一个典型的不可变类，String 对象创立进去就不可能被扭转。创立出的字符串将寄存在数据区，保障每个字符串常量只有一个，不会产生多个正本。
• 假如 ”hello” 的内存地址 xxxxx, 申明 s0 变量时给 s0 赋值 ”hello” 实际上让 s0 变量援用 ”hello” 的内存地址 xxxxx; 当咱们再申明 变量 s1 也赋值 ”hello” 的时候实际上也是间接把曾经存在的 ”hello” 的内存地址给 s1 援用。
• String sO = "hello"; String s1 = "hello"; Strings2 ="he" +"!"+"o"; (多级拼接)

2.4.2 数据类型转换

• 主动类型转换: 容量小的类型主动转换为容量大的数据类型。
• 数据类型按容量大小排序为: 
• ASCII 码: 上个世纪 60 年代，美国制订了一套字符编码，对英语字符与二进制位之间的关系，做了对立规定。这被称为 ASCII 码。ASCII 码一共规定了 128 个字符的编码，比方空格 ”SPACE” 是 32 (二进制 00100000)，大写的字母 A 是 65 (二进制 01000001）。
• 留神：char类型的字符在参加整数运算时，是转化成 ASCII 码值后再进行计算的。
• 有多种类型的数据混合运算时，零碎首先主动将所有数据转换成容量最大的那种数据类型，而后再进行计算。
• byte,short.char 之间不会互相转换，他们三者在计算时首先转换为 int 类型。
•  当把任何根本类型的值和字符串值进行连贯运算时(+)，根本类型的值将主动转化为字符串类型。eg: String str = "err" + 1+ 2+3; 输入后果是 err123
• System.out.println(3+4+"hello"); 输入后果是 7hello

2.4.3 强制类型转换

• 主动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。应用时要加上强制转换符()，但可能造成精度升高或溢出, 分外要留神。
•  通常，字符串不能间接转换为根本类型，但通过根本类型对应的包装类则能够实现把字符串转换成根本类型。
• 如: Stringa="43"; int j= Integer.parselnt(a);
• boolean类型 不能够 转换为其它的数据类型。
• 隐式转换类型和强制转化类型。
• 数字类型的运算中，多个雷同类型变量参加的运算，变量要先转换为绝对应的数据类型的默认类型(比方两个 byte 类 的变量相加，会先把两个 byte 类型的变量转换成默认的 int 类型之后再计算，失去的后果是 int 类型)。留神是数据类型的默认类型。

2.5 运算符

2.5.1 算术运算符

留神：

• 如果对正数取模，能够把模数负号疏忽否记，如: 5%-2=1。但被模数是正数则不可疏忽。此外，取模运算的后果不肯定总是整数。
• 对于除号“/”, , 它的整数除和小数除是有区别的：整数之间做除法时，只保留整数局部而舍弃小数局部。例如: int x=3510;x= x/1000*1000; x 的后果是? 
• “+”除字符串相加性能外，还能把非字符电转换成字符串。例如:System.out.printIn("5+5="+5+5); //` 打印后果是? 5+5=55`
• 以下二者的区别: // 这个是数学运算 System.out.println('*'+ t'+'*"); // 字符串拼接 System.out.println("*"+"t'+'*);

2.5.2 赋值运算符

• 符号: =。当“=”两侧数据类型不统一时，能够应用主动类型转换或应用强制类型转换准则 进行解决。反对间断赋值。
•  扩大赋值运算符：+=,-=, *=, /=, %=；在应用扩大赋值运算符时，变量在参加运算时会把后果 主动强制转换 为以后变量的类型。

2.5.3 比拟运算符

留神：比拟运算符的后果都是 boolean 型，也就是要么是 true，要么是 false。比拟运算符“==”不能误写成“=”。 

2.5.4 逻辑运算符

• 逻辑运算符用于连贯布尔型表达式，在 Java 中不能够写成3<x<6, 应该写成x>3 &  x<6。
• “&”和“&&”的区别: 单 & 时，右边无论虚实，左边都进行运算; 双 & 时，如果右边为真，左边参加运算，如果右边为假，那么左边不参加运算。
• “|”和“||”的区别同理，|| 示意: 当右边为真，左边不参加运算。.
• 异或 (^) 与或 (|) 的不同之处是：当左右都为 true 时，后果为 false。
• 了解：异或，谋求的是“异”!

2.5.5 位运算

2.5.6 三元运算符

• 格局: (条件表达式)? 表达式 1: 表达式 2; 条件表达式为 true，运算后的后果是表达式 1; 为 false，运算后的后果是表达式 2。

第三章：程序流程管制

留神：

• switch(表达式)中表达式的返回值必须是下述几种类型之一: byte, short, char, int, 枚举，String；
• case 子句中的值必须是常量，且所有 case 子句中的值应是不同的；
• default 子句是可任选的，当没有匹配的 case 时，执行 default；
• break 语 句用来在执行完一个 case 分支后使程序跳出 switch 语句块；如果没有 break，程序会程序执行到 switch 结尾。

非凡流程管制语句 1

 break 语句：break 语句用于终止某个语句块的执行 

{
…..
break;
}

非凡流程管制语句 2 

• continue 语句：continue 语句用于跳过某个循环语句块的一次执行；
• continue 语句呈现在多层嵌套的循环语句体中时，能够通过标签指明要跳过的是 哪一层循环。
• continue 语句用法举例:

• public class ContinueTest {

  public static void main(String args[]){for (inti=0;i< 100;i++){if (i%10==0)       continue;       System.out.println();}

  }
  }

非凡流程管制语句 3

•  return: 并非专门用于完结循环的，它的性能是完结一个办法。当一个办法执行到一个 return 语句时，这个办法将被完结。
• 与 break 和 continue 不同的是，return 间接完结整个办法，不论这个 return 处于多少层循环之内。

第四章：数组

4.1 一维数组

4.1.1 申明与初始化

一维数组的申明形式：type var[]或 type[] var; 

• 动静初始化: 数组申明且为数组元素调配空间与赋值的操作离开进行 

  int[] arr = new int[3];
  arr[0] = 3;
  arr[1] = 9;
  arr[2] = 8;

• 动态初始化: 在定义数组的同时就为数组元素调配空间并赋值。

  int a[] = new int[]{3，9，8};
  int[] a = {3,9,8};

4.1.2 数组元素的援用 

• 定义并用运算符 new 为之调配空间后，才能够援用数组中的每个元素；
• 数组元素的援用形式: 数组名[数组元素下标]
• 数组元素下标能够是整型常量或整型表达式。如a[3],b[i],c[6*i]; 
• 数组元素下标从 0 开始; 长度为 n 的数组非法下标取值范畴:0—>n-1; 如int a[]=new int[3]; 可援用的数组元素为a[0]、a[1]、a[2]；
• 每个数组都有一个属性 length 指明它的长度，例如: a.length 指明数组 a 的长度(元素个数) 
• 数组一旦初始化，其长度是不可变的。

数组元素的默认初始化

数组是援用类型，它的元素相当于类的成员变量，因而数组一经调配空间，其中的每个元素也被依照成员变量同样的形式被隐式初始化。例如: 

public class Test {

public static void main(String argv[]){int a[]= new int[5];
    System.out.println(a[3]); //a[3]的默认 值为 0 

}

4.2 多维数组

4.3 数组常见问题

第五章：面向对象编程

5.1 面向对象与面向过程 

5.1.1 概念

• 面向对象 (OOP) 与面向过程(POP)：①二者都是一种思维，面向对象是绝对于面向过程而言的。面向过程，强调的是性能行为。面向对象，将性能封装进对象，强调具备了性能的对象。② 面向对象更加强调使用人类在日常的思维逻辑中采纳的思维办法与准则，如抽 象、分类、继承、聚合、多态等。
• 面向对象的三大特色 ①封装(Encapsulation) ②继承(Inheritance) ③多态(Polymorphism)。

5.1.2Java 类及类的成员

• Java 代码世界由诸多不同性能的类形成。
• 属性: 对应类中的成员变量 
• 行为: 对应类中的成员办法 

类的语法格局 :

修饰符 class 类名{

属性申明;
办法申明; 

}

阐明: 修饰符 public: 类能够被任意拜访
类的注释要用{括起来

举例:
public class Person{

public int age ;// 成员变量, 类的成员变量能够先申明，不必初始化，类成员变量是有默认值,
//int 的默认值是 0,String 是 null
// 申明私有变量 age
public void showAge() { / 申明办法 showAge()
    System.out.println(age);
}

}

创立 Java 自定义类

• 步骤:
• 定义类(思考修饰符、类名)；
• 编写类的属性(思考修饰符、属性类型、属性名、初始化值)；
• 编写类的办法(思考修饰符、返回值类型、办法名、形参等)。

5.1.3 对象的创立和应用

• 应用 new + 结构器 创立一个新的对象; 
• 应用“对象名. 对象成员”的形式拜访对象成员(包含属性和办法) ; 

5.1.4 类的成员属性

• 语法格局: 修饰符类型属性名 = 初值；阐明：修饰符 private：该属性只能由该类的办法拜访。修饰符 public：该属性能够被该类以外的办法拜访。类型: 任何根本类型，如 int、boolean 或任何类。

• 举例: 

  public class Person{

  private int age;    // 申明 private 变量 age  
  public String name = "Lila"; // 声 明 public 变量 name} 
  
  

补：

• 变量的分类：成员变量与局部变量；
• 在办法体外，类体内申明的变量称为成员变量。
• 在办法体外部申明的变量称为局部变量。

留神：

public static string sex = n 男 ”://static, 意思是动态的，这样的变量不须要类实例话成对象就能够应用，
// 间接就能够通过类名. 属性这样的形式间接调用，这样的变量叫做类变量

成员变量 (属性) 和局部变量网区别

• 成员变量：成员变量定义在类中，在整个类中都能够被拜访。成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存 中。成员变量有默认初始化值；成员变量的权限修饰符能够依据须要，抉择任意一个。
• 局部变量：局部变量只定义在部分范畴内，如：办法内，代码块内等。局部变量存在于 栈内存中。作用的范畴完结，变量空间会主动开释。局部变量没有默认初始化值，每次必须显式初始化。局部变量申明时不指定权限修饰符。

5.1.5 类的成员之二：办法 

• 语法格局: 修饰符 返回值类型 办法名 (参数列表) {办法体语句;} 阐明: 修饰符: public, private, protected 等。返回值类型：return语句传递返回值。没有返回值: void。举例: 

  public class Person{
  private int age; public int getAge() { return age;
  } // 申明办法 getAge public void setAge(int i) {

    // 声 明办法 setAge,        
    age=i; // 将 参数 j 的值赋给类的成员变量 age   

  }}

• 对象的创立和应用 举例:

如果创立了一个类的多个对象，对于类中定义的属性，每个对象都领有各自的一套正本，且互不烦扰。

public class Zoo{

public static void main(String args[]){Animal xb=new Animal();Animal xh=new Animal();      
xb.legs=4;   
xh.legs=0;    
System.out.println(xb.legs); //4    
System.out.println(xh.legs); //0    
xb.legs=2;    System.out.println(xb.legs); //2    
System.out.println(xh.legs); //0    

}}

办法(method)

• 什么是办法(函数) 

办法是类或对象行为特色的形象，也称为函数。
Java 里的办法不能独立存在，所有的办法必须定义在类里。

修饰符 返回值类型 办法名(参数类型形惨 1, 参数类型形参 2, … {

程序代码
return 返回值;

}
其中:
形式参数: 在办法被调用时用于接管内部传入的数据的变量。
参数类型: 就是该形式参数的数据类型。
返回值: 办法在执行结束后返还给调用它的程序的数据。
返回值类型: 办法要返回的后果的数据类型。
实参: 调用办法时理论传给函数形式参数的数据。

• 办法的调用 

办法只有被调用才会被执行；

• 办法调用的过程剖析：

留神：

• 没有具体返回值的状况，返回值类型用关键字 void 示意，那么该函数中的 return 语句如果在最初一行能够省略不写。
• 定义方法时，办法的后果应该返回给调用者，交由调用者解决。
• 办法中只能调用办法，不能够在办法外部定义方法。

办法的重载

• 重载的概念：

在同一个类中，容许存在一个以上的同名办法，只有它们的参数个数或者参数类型不同即可。

• 重载的特点: 

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，依据办法参数列表的不同来区别。

•  重载示例: 

// 返回两个整数的和
int add(int x,int y){return X+V;}
// 返回三个整数的和
int add(int x.int y.int z){return x+V+Z;}
// 返回两个小数的和
double add(double x,double y){return x+y;}

办法的可变个数形参

// 上面采纳数组形参来定义方法
public static void test(int a ,String[] books);
// 以可变个数形参来定义方法
public static void test(int a ,tring..books);

阐明:

1. 可变参数: 办法参数局部指定类型的参数个数是可变多个

 2. 申明形式: 办法名(参数的类型名 … 参数名)

 3. 可变参数办法的应用与办法参数局部应用数组是统一的 

4. 办法的参数局部有可变形参，须要放在形参申明的最初 

/**
用 java 特有的 … 的形式来传递可变个数的参数，这种参数在应用时与数组的应用形式雷同
@param args
*/
public void printInfol (String… args) {

for(inti= 0; i < args.length; 1++) {System. out. println (args [i]);

}

办法的参数传递

• 办法，必须有其所在类或对象调用才有意义。若办法含有参数：

形参: 办法申明时的参数 

实参: 办法调用时理论传给形参的参数值 

• Java 的实参值如何传入办法呢? 

Java 里办法的参数传递形式只有一种：值传递 。行将理论参 数值 的正本(复制品) 传入办法内，而参数自身不受影响。

jvm 内存模型

根本数据类型值保留在栈中，援用对象值保留在堆中，栈中存的是值在堆中的地址。

总结：办法的参数传递

1、如果办法的形参是根本数据类型，那么实参 (理论的数据) 向形参传递参数时，就是间接传递值，把实参的值复制给形参；

2、如果办法的形参是对象，那么实参(理论的对象)，向形参传递参数 的时，也是把值给形参，这个值是实参在栈内存中的值，也就是援用对象 在堆内存中的地址；

3、根本数据类型都是保留在栈内存中，援用对象在栈内存中保留的是引 | 用对象的地址，那么办法的参数传递是传递值(是变量在栈内存的当中的值)。

5.2 对象

5.2.1 对象的产生

当一个对象被创立时，会对其中各种类型的成员变量主动进行初始化赋值。除了根本数据类型之外的变量类型都是援用类型，如下面的 Person 及后面讲过的数组。

5.2.2 匿名对象

咱们也能够不定义对象的句柄，而间接调用这个对象的办法。这样的对象叫做匿名对象。如: new Person().shout(); 

应用状况：

• 如果对一个对象只须要进行一次办法调用，那么就能够应用匿名对象。
• 咱们常常将匿名对象作为实参传递给一个办法调用。

5.3 包和援用

5.3.1 关键字 package

• package 语句作为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格局为: 

package 顶层包名. 子包名;
举例: packTest.java
package p1; // 指 定类 Test 属于包 p1
public class Test{

public void display(){System.out.println("in method display()"); 

}

• 包对应于文件系统的目录，package 语句中，用“.”来指明包 (目录) 的档次;
• 包通常用小写单词，类名首字母通常大写。
• Java 中的包 package等同于文件夹，有多级，也就是包下能够由包和文件。

5.3.2 关键字 import

• 为应用定义在不同包中的 Java 类，需用 import 语句来引入指定包档次下所须要的类或全副类(.*)。import 语句通知编译器到哪里去寻找类。
• 语法格局: import 包名[子包名...]. < 类名 |*>

• 利用举例:

  import p1.Test; //import p1.*; 示意引入 p1 包中的所有类
  public class TestPackage{

  public static void main(String args[]){Test t = new Test();    //Test 类在 p1 包中定义   
  t.display();}}
  
  

留神：

➢若引入的包为:java.lang, 则编译器默认可获取此包下的类，不须要再显示申明。

➢import 语句呈现在 package 语句之后、类定义之前

➢一个源文件中可蕴含多个 import 语句

➢能够应用 import lee. ; 语句，表明导入 lee 包下的所有类。而 lee 包下 sub 子包内 的类则不会被导入。import lee.sub.;

➢import 语句不是必须的，可保持在类里应用其它类的全名

➢JDK 1.5 退出 import static 语句

5.3.3jdk 中的次要包介绍

1. java.lang— 蕴含一些 Java 语言的外围类，如 String、Math、Integer、System、Thread，提供罕用性能。
2. java.net– 蕴含 执行与网络相干的操作的类和接口。
3. java.io — 包 含能提供多种输出 / 输入性能的类。
4. java.util— 蕴含一些实用工具类，如定义零碎个性、接口的汇合框架类、应用与日期日历相干的函数。
5.   java.text— 蕴含了一些 java 格式化相干的类
6. java.sql— 蕴含了 java 进行 JDBC 数据库编程的相干类 / 接口 
7. java.awt— 蕴含了形成形象窗口工具集 (abstract window tookits) 的 多个类，这些类被用来构建和管理应用程序的图形用户界 面(GUI)。
8. java.applet— 蕴含 applet 运行所需的一些类。

5.4 面向对象特色之一：封装和暗藏

5.4.1 封装实现

Java 中通过将数据申明为公有的 (private)，再提供公共的 (public) 办法：getXxx()和 setXxx()实现对该属性的操作，以实现下述目标：

• 暗藏一个类中不须要对外提供的实现细节; 
• 使用者只能通过当时定制好的办法来拜访数据，能够不便地 退出管制逻辑，限度对属性的不合理操作;
• 便于批改，加强代码的可维护性; 

5.4.2 四种拜访权限修饰符