Java 学习笔记
计算机知识
-
二进制
位权 ... 16 8 4 2 1
1 1 0 0=12
-
字节
位（bit），一个数字0或者一个数字1，代表一位。
字节（Byte），每逢8位是一个字节，是数据存储的最小单位。
1 Byte = 8 bit
100Mbps /8 15MB/S
1 KB = 1024 Byte
1 MB = 1024 KB
1 TB = 1024 GB
1 PB = 1024 TB
1 EB = 1024 PB
1 ZB = 1024 EB
命令提示符(command)
-
MS-DOS（Microsoft Disk Operating String）
-
切换盘符 c: C:
-
进入文件夹 cd 文件夹名称
-
-
返回上一级 cd ..
-
直接回根路径 cd \
-
产看当前文件夹 dir
-
清屏 cls
-
退出 exit
-
ipconfig
-
systeminfo
-
studown -s -t 3600 按秒计算
-
tree 树形列出文件夹结构
win+r
-
calc 计算器
-
mspaint 画板
-
notepad 记事本
-
在指定文件夹中，通过在路径地址输入cmd可快速用命令符打开该文件。
Java开发
Java虚拟机--JVM
-
JVM（Java Virtual Machine） 核心
-
JRE（Java Runtime Environment）运行
-
JDK（Java Development Kit） 开发
-
JDK { 编译器等开发工具、JRE（运行类库、JVM）}
public static void main (String[]args){
}
关键字
-
完全小写的字母
-
有特殊颜色的
基本数据类型
-
整数型 byte short int long
-
浮点型 float double
-
字符型 char
-
布尔型 boolean
引用数据类型
-
字符串、数组、类、接口、Lambda
注意事项
-
字符串不是基本类型，而是引用类型。
-
浮点型可能只是一个近似值，并非精确的值。
-
数据范围与字节不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
-
浮点数当中默认类型是double，如果一定要使用float类型，需要加上一个后缀F。
-
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L，推荐使用大写字母后缀。
变量
-
程序运行期间，内容可以发生改变的量。
-
创建一个变量并且使用的格式：
数据类型 变量名称；// 创建了一个变量
-
变量名称 = 数据值； // 赋值，将右边的数据值，赋值交给左边的变量
-
一步到位的格式： 数据类型 变量名称 = =数据值； // 在创建一个变量时，立刻放入指定的数据值。
public class Demo01Variable () {
public static void main (String[] args){
//创建一个变量
int num1;
// 向变量当中存入一个数据
num1 = 10;
//打印输出变量
System.out.println(num1);
// 改边变量当中本来的数字，变成一个新的数字
num1 = 20;
System.out.println(num1);
int num2 = 25;
System.out.println(num2);
}
}
-
如果创建多个变量，那么变量之间的名称不可以重复。
-
对于float和long类型来说，字母后缀F和L不要丢掉。
-
如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
-
没有进行赋值的变量，不能直接使用，一定要赋值之后，才能使用。
-
变量使用不能超过作用域的范围。
-
可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。
数据类型转换
-
当数据类型不一样时，将会发生数据类型转换。
自动转换（隐式）
-
特点：代码不需要进行特殊处理，自动完成。
-
规则：数据范围从小到大。
强制类型转换（显式）
-
特点：代码需要进行特殊的格式处理，不能自动完成。
-
格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据。
注意事项
-
强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
-
byte、short、char这三种类型都可以发生数学运算，例如加法“+”。
-
byte、short、char这三种类型在运算的时候，都会被首先提升成为int类型，然后计算。
-
boolean类型不能发生数据类型转换。
ASCII编码表
-
数字和字符对照关系表（编码表）：
-
ASCII码表：American Standard Code for Information Interchange 美国信息交换标准代码
-
Unicode 码表：万国码，也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含有更多的字符。
48----“0”，65----“A”，97----“a”
运算符
算数运算符
| 算数运算符包括： | |
|---|---|
| 加 | + |
| 减 | - |
| 乘 | * |
| 除 | / |
| 取模（取余数） | % |
| 自增自减 | ++、-- |
注意事项
-
一旦运算当中有不同类型的数据，那么将会是数据类型范围打的那种。
-
对于整数的除法来说，取模运算才有余数的意义。
-
在单独使用自增自减的时候，前++和后++没有任何区别。在混合使用的时候，有重大区别：
-
如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。 【先加后用】
-
如果是【后++】，那么首先使用变量本来的数值，然后【再让变量+1】。 【先用后加】
-
赋值运算符
| 赋值运算符包括： | 将右边的值赋给左边的变量 |
|---|---|
| = | 等于号 |
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等 |
比较运算符
| 比较运算符 | |
|---|---|
| == | 两边数据是否相等，相等结果是true。 |
| < | 左边是否小于右边，小则true |
| > | 是否左大于右，大则true |
| <= | 是否左边小于或者等于右边，如果小于则true |
| >= | 是否左边大于或者等于右边，如果大于则true |
| != | 如果不等于则true |
逻辑运算符
| 比较运算符 | |
|---|---|
| 与（并且） | && |
| 或（或者） | || |
| 非（取反） | ! |
-
短路：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省了一定的性能。
一元运算符
-
只需要一个数据就可以进行操作的运算符。例如：取反！、自增++、自减--
二元运算符
-
需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符
-
需要三个数据才可以进行操作的运算符,三元运算符的结果必须被使用。
-
格式：
数据类型 变量名称 = 条件判断 ？ 表达式A : 表达式B; -
流程：
首先判断条件是否成立：
如果成立则为true，那么将表达式A的值赋值给左侧的变量
如果不成立则false，那么将表达式B的值赋值给左侧的变量
int a = 10;
int b = 20;
int max = a > b ? a : b;
方法
-
基本格式
public static void 方法名称(){
}-
方法名称和变量的命名规则一样，小驼峰。
-
switch
注意事项：
-
多个case后面的数值不可以重复。
-
switch 后面的小括号当中只能是下列数据类型：
-
基本数据类型：byte、short、char、int
-
引用数据类型：String字符串、enum枚举
-
循环结构的基本组成部分：
-
初始化语句
-
条件判断
-
循环体
-
步进语句
方法的重载
-
Overload，多个方法的名称一样，但是参数列表不一样。
-
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。
-
-
参数个数不同
-
参数类型不同
-
参数的多类型顺序不同
-
-
方法重载与下列因素无关：
-
与参数的名称无关
-
-
-
Java的内存需要划分为5个部分：
-
-
局部变量：方法的参数，或者是方法{}内部的变量。
-
作用域：一旦超出作用域，立刻从栈内存当中消失。
-
-
堆（Heap）：凡是new出来的东西，都在堆当中。
-
堆内存里面的东西都有一个地址值：16进制
-
堆内存里面的数据，都有默认值。规则：
如果是整数 默认为0
如果是浮点数 默认为0.0
如果是字符 默认为‘\u0000’
如果是布尔 默认为false
如果是引用类型 默认为null
-
-
方法区（Method Area）：存储.class相关信息，包含方法的信息。
-
本地方法栈（Native Method Stack）：与操作系统相关。
-
-
面向过程
-
当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。（强调步骤）
int [] array = {1,2,3,4,5,6};
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1 )
System.out.println("]");
else
System.out.print(array[i]+", ");
}
面向对象
-
当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。（强调对象）
-
使用面向对象
-
找一个JDK给我们提供好的Array类
-
其中有一个toString方法，直接就能把数组变成想要的格式的字符串
-
int [] array = {1,2,3,4,5,6};
System.out.println(Arrays.toString(array));
特点
-
面向对象思想是一种更符合我们思想习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者，面向对象的语言中，包含了三大基本特征，即封装、继承、多态。
类与对象
什么是类
-
类：是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为来描述该类事物。
-
属性：该事物的状态信息。
-
行为：该事物能做什么。
-
举例：小猫
属性：名字、体重、年龄、颜色
行为：走、跑、叫
什么是对象
-
对象：是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。
-
现实中，一类事物的一个实例：一只小猫
类与对象的关系
-
类是对一类事物的描述，是抽象的
-
对象是一类事物的实例，是具体的
-
类是对象的模板，对象是类的实体
类的定义
事物与类的对比
成员变量：对应事物的属性
成员方法：对应事物的行为
类的定义格式
public class Student {
//成员变量
private String name;
private int age;
//成员方法
public void sleep(){
System.out.println("睡觉觉！");
}
public void eat(){
System.out.println("吃饭饭！");
}
public void study(){
System.out.println("学习！");
}
}
注意事项
-
成员变量是直接定义在类当中的，在方法外边。
-
成员方法不要写static关键字。
使用
-
通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
-
导包，也就是指出需要使用的类，在什么位置。
import 包名称.类名称;
import cn.edu.aku.demo.Student;对于和当前类属于同一个包的情况，可以省略导包语句不写。
-
创建，格式
类名称 对象名 = new 类名称();
Student stu = new Student(); -
使用，分为两种情况
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
-
java中基本数据类型的默认值
1、整数类型（byte、short、int、long）的基本类型变量的默认值为0。
2、单精度浮点型（float）的基本类型变量的默认值为0.0f。
3、双精度浮点型（double）的基本类型变量的默认值为0.0d。
4、字符型（char）的基本类型变量的默认为 “/u0000”。
5、布尔性的基本类型变量的默认值为 false。
6、引用类型的变量是默认值为 null。
7、数组引用类型的变量的默认值为 null。除关键数组变量的实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。
-
练习
public class Phone {
String brand;
double price;
String color;
public void call(String who){
System.out.println("给"+who+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
}public class Demo03Phone {
public static void main(String[] args) {
Phone phone = new Phone();
phone.brand = "华为";
phone.price = 5999.6;
phone.color = "白色";
Phone phone2 = new Phone();
phone2.brand = "小米";
phone2.price = 3999.6;
phone2.color = "黑色";
System.out.println("第一部手机:"+phone.brand+","+phone.price+","+phone.color+"。");
System.out.println("第二部手机:"+phone2.brand+","+phone2.price+","+phone2.color);
phone.call("万仙山");
phone.sendMessage();
// 将 two 当中保存的对象地址值赋值给 three
Phone three = two ;
}
}public class demo06PhoneParam {
public static void main(String[] args) {
Phone one = new Phone();
one.brand = "华为";
one.price = 5999.6;
one.color = "白色";
method(one);
}
public static void method(Phone param){
System.out.println(param.brand);
System.out.println(param.price);
System.out.println(param.color);
}
}public class demo07PhoneReturn {
public static void main(String[] args) {
Phone two = getPhone();
System.out.println(two.brand+","+two.price+","+two.color);
}
public static Phone getPhone(){
Phone one = new Phone();
one.brand = "华为";
one.price = 5999.6;
one.color = "白色";
return one;
}
}
局部变量和成员变量
-
定义的位置不一样
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
-
作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类全都可以使用
-
默认值不一样
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
public class demo08VariableDifference {
String name;
public void methodA(){
int num = 20;
System.out.println(num);
System.out.println(name);
}
public void methodB(int param){ // 方法的参数就是局部变量
// 参数在方法调用时，必然会被赋值的。
System.out.println(param);
int age;
// System.out.println(age); // 没赋值不能用
// System.out.println(num); // 错误写法
System.out.println(name);
}
} -
内存的位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
-
生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失。
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。
封装
-
封装性在Java中体现
-
方法就是一种封装
-
关键字private也是一种封装
-
public class demo01Method {
public static void main(String[] args) {
int [] array = {5,15,20,25,300,10};
int max = getMax(array);
System.out.println("最大值："+max);
}
public static int getMax(int [] array){
int max = array[0];
for (int i = 1; i <array.length ; i++) {
if (array[i] > max)
max = array[i];
}
return max;
}
}
封装就是将一些细节信息隐藏起来，对于外界不可见。
-
private的使用 （提高代码的安全性）
/**
* @desciption: 问题描述：定义Person 的年龄时，无法阻止 不合理的数值设置进来。
* 解决方法 ： 用 private 关键字 将需要保护的成员变量进行修饰
* 一旦使用了 private 进行修饰，那么本类当中仍然可以随意访问
* 但是！ 超出了本类 范围之外就不能直接在访问了
*
* 间接访问 private 成员变量，就是定义一对儿 Getter和 Setter 方法
*
* 对于Getter 来说，不能有参数，返回这类型 和成员变量对应
* 对于Setter 来说，不能有返回值，参数类型 和成员变量对应
*/
class Person {
String name;
private int age;
// 获取age数据
public int getAge() {
return age;
}
// 设置age数据
public void setAge(int num) {
if (num >= 0 && num < 100){
age = num;
}
}
public void show(){
System.out.format("我叫%s，年龄%d",name,age);
}
}
public class demo02Person {
public static void main(String[] args) {
Person person = new Person();
person.show();
System.out.println();
person.name = "赵丽颖";
// person.age = -18; // 直接访问 private 内容，错误写法！
person.setAge(18);
person.show();
}
}
-
对于基本类型当中的Boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
this关键字的作用
-
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
-
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名。
public void sayHelloNoThis(String name){
System.out.println(name+"你好，我是"+name);
}
public void sayHello(String name){
System.out.println(this.name+"你好，我是"+name);
}person.name = "王思聪";
person.sayHelloNoThis("王健林");
person.sayHello("王健林");打印结果：
王健林你好，我是王健林
王思聪你好，我是王健林
构造方法
-
构造方法是专门用来创建对象的方法，当我们通过关键字new 来创建对象时，其实就是在调用构造方法。
-
格式：
public 类名称(参数类型 参数名称){
方法体
} -
注意事项：
-
构造方法的名称必须和所在的类名完全一样，就连大小写也要一样。
-
构造方法不要写返回值类型，连 void 都不写。
-
构造方法不能return一个具体的返回值
-
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不用做。
public Student（）{}
-
一旦编写了至少一个构造方法，那么编译器将不再赠送。
-
定义一个标准的类
一个标准的类通常要拥有下面四个组成部分: 1.所有的成员变量都要使用private关键字修饰 2.为每一个成员变量编写一 对儿Getter/Setter方法 3.编写一个无参数的构造方法 4.编写一个全参数的构造方法 这样标准的类也叫做 Java Bean
API
概述
API(Application Programming Interface),应用程序编程接口。Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类,并得知如何使用它们。
文档地址：下载:https://wwp.lanzouy.com/iruoA0fby0hi 密码:ghrq
Scanner类
-
Scanner 类的功能：可以实现键盘输入数据，到程序当中。
引用类型的一般使用步骤：
-
导包
import 包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。（只有java.lang包下的内容不需要导包，其他的包都需要import语句）
-
创建
类名称 对象名 = new 类名称();
-
使用
对象名.成员方法名();
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
String str = sc.next();
// 其实从键盘输入的都是字符串，而 nextInt() 是把输入的字符串转化成数值
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
System.out.println(maxNum(a,b,c));
}
public static int maxNum(int a, int b, int c){
int max = a > b ? a : b;
return max > c ? max : c;
}
匿名对象
-
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();
-
注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
-
public class demo06Anonymous {
public static void main(String[] args) {
// 普通使用方式
// Scanner sc = new Scanner(System.in);
// int num = sc.nextInt();
// 匿名对象的方式
// int num = new Scanner(System.in).nextInt();
// System.out.println("输入的是："+num);
// 使用一般写法传入参数
// Scanner sc = new Scanner(System.in);
// methodParam(sc);
// 使用匿名对象来进行传参
// methodParam(new Scanner(System.in));
Scanner sc = methodScanner();
int num = sc.nextInt();
System.out.println("输入的是："+num);
}
public static void methodParam(Scanner sc){
int num = sc.nextInt();
System.out.println("输入的是："+num);
}
public static Scanner methodScanner(){
return new Scanner(System.in);
}
}
-
#end
浙公网安备 33010602011771号