Dos命令
-
打开CMD的方式
-
开始+系统+命令提示符
-
win+R 输入cmd打开控制台
-
在任意文件夹下按住shift键右键,打开powerShell
-
资源管理器的地址栏前面加上cmd 路径
可右键选择以管理员方式运行
-
-
常见的DOS命令
#切换盘符 盘符+:+回车 D: #查看当前目录下的所有文件 dir+回车 #切换目录 cd(change directory)+名 #返回上级目录 cd.. #清屏 cls #退出终端 exit #查看电脑的IP ipconfig #打开应用 calc 计算器 mspaint 绘图 notepad 记事本 #ping命令 ping www.baidu.com #创建文件夹 md +文件名(make directory) #创建文件 cd> 文件 #删除文件 del 文件名 #删除文件夹 rd 文件夹
Java入门
Write Once,Run Anywhere
Java三大版本
- JavaSE:标准版(桌面程序、控制台开发……)
- JavaME:嵌入式开发(手机、小家电……) (现在几乎没了)
- JavaEE:E企业级开发(Web端,服务器开发……)
JDK JRE与JVM
-
JDK:Java Development Kit(java开发包)
-
JRE:Java Runtime Environment
-
JVM:Java Virtual Machine
卸载与安装JDK
-
卸载JDK
- 删除Java的安装目录
- 删除JAVA_HOME
- 删除path下关于java的目录
- java -version检查
-
安装JDK
-
下载JDK8
-
安装JDK
-
记住安装的路径
-
配置环境变量
-
我的电脑->右键->属性
-
环境变量->JAVA_HOME
-
配置path变量
-
测试是否安装成功,java -version
-
-
HelloWorld
-
新建一个java文件
- 文件后缀名为.java
- Hello.java
-
编写代码
public class Hello{ //public的类名和文件名一定要相同 public static void main(String[] args){ System.out.println("Hello World"); } }
-
编译
javac Hello.java
,生成class文件 -
运行class文件,
java class名
Java程序运行机制
- 编译型:编译型语言是指程序在执行之前需要一个专门的编译过程,把程序源文件编译为机器语言的文件,运行时不需要重新编译,执行效率高,但缺点是,编译型语言依赖编译器,跨平台性差。
- 举例:比如C语言程序的执行过程,要先将后缀为.c的源文件通过编译、链接为后缀为.exe的可执行文件,才能运行。
- 解释型:解释型语言是指源代码不需要预先进行编译,在运行时,要先进行解释再运行。解释型语言执行效率低,但跨平台性好。
- 举例:比如Python程序执行过程,我们写好代码,直接运行即可(运行前有解释的过程)。
IDEA安装
IDE(Integrated Development Environment):集成开发环境
官网安装即可
Java基础语法
注释
-
注释并不会被执行,是给人看的
-
书写注释是一个非常好的习惯
-
平时写代码一定要注意规范
-
Java中的注释有三种:
- 单行注释
- 多行注释
- 文档注释
public class Hello {
public static void main(String[] args) {
//单行注释
//输出Hello World
System.out.println("Hello World!");
/*多行注释
1
2
3
4
*/
//JavaDoc:文档注释 /** */
/**
* @Description Hello
* @Author Cez
*/
}
}
标识符和关键字
-
关键字
随着深入的学习,并不需要刻意去记忆
-
标识符
Java所有的组成部分都需要名字。类名、变量名和方法名都被称为标识符
- 标识符不可以和关键字相同
- 所有标识符都应该以字母、美元符或者下划线开始
- 首字母之后可以是字母、美元符、下划线或数字的任意字符组合
- 标识符是大小写敏感的
- 真别用拼音命名,不规范,太low了
数据类型
-
强类型语言
要求变量的使用严格符合规定,所有变量都必须先定义后使用
-
Java的数据类型分为两类:基本类型,引用类型
-
基本类型:
public class Demo02{ public static void main(String[] args) { //八大基本数据类型 //整数 int num = 10; byte num2 = 30; short num3=40; long num4 = 100L;//后加L表示为long类型 //小数:浮点数 double num5 = 51.321;//java中默认小数为double类型 float num6 = 50.1f;//后加f表示为float类型 //字符类型 char name = 'C'; //布尔值 boolean flag = true; flag = false; } }
-
引用类型
除了基本类型的类型都是引用类型
-
-
浮点数float 有限 离散 舍入误差 大约 接近但不等于
最好安全避免使用浮点数进行比较
-
所有字符本质上还是数字
编码 Unicode 2个字节
-
转义字符
\t \n等
public class Demo02{
public static void main(String[] args) {
//八大基本数据类型
//整数
int num = 10;
byte num2 = 30;
short num3=40;
long num4 = 100L;//后加L表示为long类型
//小数:浮点数
double num5 = 51.321;//java中默认小数为double类型
float num6 = 50.1f;//后加f表示为float类型
//字符类型 占两个字节
char name = 'C';
//布尔值
boolean flag = true;
flag = false;
}
}
类型转换
public class Demo01 {
public static void main(String[] args) {
int i = 128;
byte b= (byte)i; //数值溢出,其对应数值就是-128
//强制转换 (类型)变量名称 高-->低
//自动转换 低-->高
double c = i;
/*
注意点:
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换为低容量时,需要强制转换
4.转换的时候可能存在溢出现象或精度丢失问题
*/
int money = 10_0000_0000;
//JDK7的新特性:可以用下划线分割数字,方便阅读,并不会影响数字大小
int years = 20;
long total = money*years;//默认是int,转换之前就出问题了
long total2 = (long)money*years; //先转long再输出
System.out.println(total);
System.out.println(total2);
}
}
变量、常量、作用域
- Java是一种强类型语言,每一个变量都必须声明其类型
- Java变量是程序中最基本的存储单元,其要素包括变量名、变量类型和作用域
- 注意事项:
- 每个变量都有类型,类型可以是基本类型,也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句,因此每一个声明都必须以分号结束
public class Demo01 {
public static void main(String[] args) {
//int a=1,b=2,c=3;//可读性会降低
int a = 1;
int b = 2;
int c = 3;
String name = "Cez";
double d = 123;
float f = 123f;
}
}
-
变量作用域:
类变量、实例变量、局部变量
public class Demo01 { //实例变量:从属于对象,如果不自行初始化,则为默认值 //boolean初始值为false,int double等为0,除了基本类型,其他默认值都为null String name; int age; //类变量 static static double salary = 2500; //从属于该类,随着类一起存在,一起消失 public static void main(String[] args) { //局部变量:必须声明和初始化值, int i=10; System.out.println(i); Demo01 demo01 = new Demo01(); System.out.println(demo01.age); System.out.println(salary); } public static void add(){ System.out.println(i);//error } }
-
常量
-
初始化之后不能再改变值!不会变动的值
-
所谓常量可以理解为一种特殊的变量,值被设定之后,在程序运行过程中不可以再改变
final 常量名=值; final double PI=3.14; //常量名一般使用大写字符
-
-
命名规范
- 所有变量、方法、类名要见名知意
- 类成员变量:首字母小写和驼峰原则:monthSalary
- 局部变量:首字母小写和驼峰原则
- 常量:大写字母和下划线:MAX_VALUE
- 类名:首字母大写和驼峰原则
- 方法名:首字母小写和驼峰原则
运算符
优先级:最高为(),其次为一元运算符,再次为加减乘除,再次为位运算,但是最好用括号写的明明白白
//算术运算符 + - * / % ++ --
//赋值运算符 =
//关系运算符 > < >= <= == != instanceof
//逻辑运算符 && || !
//位运算符 & | ^ ~ >> << >>>
//条件运算符 ?:
//扩展赋值运算符 += -= *= /=
//关系运算符的返回值是boolean类型,只有false和true
自增自减运算符、初始Math类
public class Demo01 {
public static void main(String[] args){
// ++ -- 自增、自减 一元运算符
int a = 3;
a++;
int b = ++a;
System.out.println("a="+a);
System.out.println("b="+b);
//幂运算
double pow = Math.pow(3,2);
System.out.println(pow);
}
}
逻辑运算符、位运算符
public class Demo01 {
public static void main(String[] args){
//逻辑运算符
//与或非
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));
System.out.println("a || b:"+(a||b));
System.out.println("!(a&&b):"+!(a&&b));
//短路运算:只要判断了前面的边大师时就能判断整个表达式的值,就不再判断后面表达式的值
int c = 5;
boolean flag = c<4 && (c++<4);
System.out.println(c); //c输出结果为5
}
}
public class Demo01 {
public static void main(String[] args){
//位运算
/*
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
位运算效率极高!
2*8 2<<3 左移乘2
16/8 16>>3 右移除以2
*/
}
}
三元运算符及小结
public class Demo01 {
public static void main(String[] args){
int a = 10;
int b = 20;
a+=b; //a = a+b
a-=b; //a = a-b
System.out.println(a);
/*
字符串连接符 + 在一个表达式中出现了String类,
则其他类型自动转换为String类,
但是在String类出现之前若有其他运算则先进行运算再转换
*/
System.out.println("ABC"+a+b);//ABC1020
System.out.println(a+b+""); //30
//x?y:z
//如果x==true,则返回y,否则返回z
int score = 60;
String level = score>60?"及格":"不及格";
System.out.println(level);
}
}
包机制
为了更好地组织类,java提供了包机制
包的本质就是一个文件夹
语法:package pkg1[.pkg2[.pkg3...]]
一般利用公司域名倒置作为包名 ```package com.baidu.www`
为了能够使用某一个包的成员,需要在Java程序中明确导入该包,使用import语句完成此功能import package
JavaDoc
JavaDoc命令是用来生成自己的API文档的
Java流程控制
用户交互Scanner
-
Java.util.Scanner是Java5的新特性,可以通过Scanner类来获取用户的输入
-
基本语法:
Scanner s = new Scanner(System.in)
-
通过Scanner类的next()和nextLine()方法获取输入的字符串,在读取前用hasNext()和hasNextLine()判断是否还有输入的数据
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描器对象,用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收:");
//接收用户输入
String str = scanner.next();//程序会等待用户输入完毕
System.out.println(str);
str = scanner.nextLine();
System.out.println("输入的内容为:"+str);
//凡是属于IO流的类如果不关闭会一直占用资源,要养成好习惯,用完就关掉
scanner.close();
}
}
Scanner进阶使用
hasNextInt()、hasNextDouble()、hasNextFloat()等等
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = 0;
float f = 0.0f;
System.out.println("请输入整数:");
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整型数据:"+i);
}else{
System.out.println("输入的不是整型数据");
}
System.out.println("请输入小数:");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("小数数据:"+f);
}else{
System.out.println("输入的不是小数数据");
}
scanner.close();
}
}
顺序结构
- Java基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行
- 它是任何一个算法都离不开的基本算法结构
if选择结构
- if单选择、双选择、多选择、嵌套结构(选择结构可以嵌套)
- 语法:
if (布尔表达式){
}else if(){
}else if(){
}else{
}
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
if (s.equals("hello")){
System.out.println(s);
}else{
System.out.println("输入的不是hello");
}
scanner.close();
}
}
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int score= scanner.nextInt();
if (score<60){
System.out.println("E");
}else if (score<70){
System.out.println("D");
}else if (score<80){
System.out.println("C");
}else if (score<90){
System.out.println("B");
}else if (score<=100){
System.out.println("A");
}else{
System.out.println("输入不合法!");
}
scanner.close();
}
}
switch选择结构
-
switch case语句判断一个变量与一系列值中某个值是否相等,每个值为一个分支
-
swtich语句中的变量类型可以是byte、short、int、char,但是从Java SE 7 开始,switch支持String类型,同时,case标签必须为字符串常量或字面量
-
case具有穿透性(若匹配到某一个case,该case中没有break语句时,则会一直执行下面所有的语句,直至遇到break或者switch结束)
switch (expression){ case value1: //语句 break; case value2: //语句 break; .... default: break; }
public class Demo01 { public static void main(String[] args) { char c = 'A'; switch (c){ case 'A': System.out.println("优秀"); break; case 'B': System.out.println("良好"); break; case 'C': System.out.println("无所谓"); break; default: break; }//自行尝试不加break的情况 } }
public class Demo01 { public static void main(String[] args) { //从Java SE 7 开始,switch支持String类型 //字符的本质还是数字 //通过反编译 java--class(字节码文件)----反编译 String name = "Craziez"; switch (name){ case "Cez": System.out.println(name); break; case "Craziez": System.out.println(name); break; default: break; } } }
部分反编译对比:
while循环
while (布尔表达式){
//循环内容
}
- 只要布尔表达式为true,循环就会一直执行
- 当布尔表达式为false时,循环就停止
- 大多数情况下是会让循环停止下来的,需要一个让表达式失效的方式来停止循环
- 少部分情况下需要循环一直执行,比如服务器的请求响应监听等
- 循环条件一直为true就会造成无限循环,正常业务要避免,否则会影响性能或造成程序卡死
public class Demo01 {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
}
}
}
do…while循环
- 对于while语句而言,如果不满足条件,则不进入循环。但有时候需要即使不满足条件,也至少执行一次。
- do…while循环类似于while循环,但是do…while循环至少执行一次
- while循环先判断后循环,do…while循环先执行后判断
for循环
-
for循环语句支持迭,有效、灵活
-
for循环执行的次数是在执行前就确定的
-
for循环最先执行初始化步骤(可以是空语句)
-
语法
for (初始化;布尔表达式;更新){ //代码语句 }
public class Demo01 { public static void main(String[] args) { int sum = 0; for (int i=1;i<=100;i++) sum+=i; System.out.println(sum); } }
在IDEA中可以使用整数常量.for的形式快捷生成从0到常量-1的for循环,如100.for
增强for循环
-
Java5引入了一种主要用于数组或集合的增强型for循环
-
语法:
for (声明语句:表达式){ //代码 }
-
声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等
-
表达式:表达式是要访问的数组名,或者是返回值为数组的方法
break continue
- break用于强制退出整个循环
- continue用于强制退出本次循环,跳过本次循环体中尚未执行的部分,接着进行下一次是否执行的判定
Java方法
什么是方法
- Java方法是语句的集合,它们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建,在其他地方被引用
- 设计方法的原则:一个方法只完成一个功能,这样有利于后期的扩展
public class Demo02 {
public static void main(String[] args) {
int result = add(1,2);
System.out.println(result);
}
//加法
public static int add(int a,int b){
return a+b;
}
}
方法的定义和调用
-
Java的方法类似于其他语言的函数,是一段用来完成特定功能的代码片段
-
方法包含一个方法头和一个方法体
-
修饰符:(这是可选的)告诉编译器如何调用该方法,定义了该方法的访问类型
-
返回值类型
-
方法名
-
参数类型
-
方法体:方法体包含具体的语句,定义该方法的功能
-
-
方法调用
- 调用方法:对象名.方法名(实参列表)
- Java支持两种调用方法的方式,根据方法是否有返回值来选择
- 当方法返回一个值的时候,方法调用通常被当作一个值
- 当方法返回值为void,方法调用一定是一条语句
public class Demo01 {
public static void main(String[] args) {
System.out.println(max(1,5));
}
public static int max(int num1,int num2){
int result=0;
if (num1>num2)
result = num1;
else if (num1<num2)
result = num2;
else {
System.out.println("num1=num2");
return 0;//终止方法
}
return result;
}
}
方法的重载
-
重载就是在一个类中,有相同的方法名称,但是形参不同的方法
-
方法重载的规则:
- 方法名称必须相同
- 参数列表必须不同(个数或类型或排列顺序)
- 方法的返回类型可以相同可以不同
- 仅仅返回类型不同不足以成为方法的重载
public class Demo01 {
public static void main(String[] args) {
System.out.println(max(1,5));
System.out.println(max(1.0,5.5));
}
public static int max(int num1,int num2){
int result=0;
if (num1>num2)
result = num1;
else if (num1<num2)
result = num2;
else {
System.out.println("num1=num2");
return 0;//终止方法
}
return result;
}
public static double max(double num1,double num2){
double result=0;
if (num1>num2)
result = num1;
else if (num1<num2)
result = num2;
else {
System.out.println("num1=num2");
return 0;//终止方法
}
return result;
}
}
命令行传参
-
有时希望运行一个程序时再传递给它消息,这时要靠传递命令行参数给main方法实现
public class Demo01 { 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 Demo01{
public static void main(String[] args) {
Demo01 demo = new Demo01();
demo.test(1,2,3,4,5);
}
public void test(int...i){
System.out.println(i[0]);//本质就是数组
}
}
递归
-
递归就是方法自己调用自己
-
递归结构包括两个部分
- 递归头:什么时候不调用自身方法。如果没有头则陷入死循环
- 递归体:什么时候需要调用自身方法
public static void main(String[] args) { Demo01 demo = new Demo01(); System.out.println(demo.f(5)); } public static int f(int n){ if (n==1) return 1; else return f(n-1)*n; }
Java数组
数组的定义
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成
- 数组中的每一个数据称作数组元素,每个数组元素可以通过一个下标访问
数组声明创建
-
首先必须声明数组变量,才能在程序中使用数组。
声明语法:
dataType[] arrayRefVar; //首选方法 或者 dataType arrayRefVar[]; //效果相同,但不是首选
-
Java语言使用new操作符创建数组
语法:
dataType[] arrayRefVar = new dataType[arraySize];//声明和创建放在一条语句
-
数组元素通过索引访问,索引从0开始
-
获取数组长度:
array.length
public class Demo01{
public static void main(String[] args){
int[] nums = new int[5];
nums[1] = 5;
System.out.println(nums[1]);
System.out.println(nums.length);
}
}
初始化及内存分析
数组是引用类型,它的元素相当于类的实例化变量,因此数组一经分配空间,其每个元素也被按照实例变量同样的方式被隐式初始化。
public class Demo01{
public static void main(String[] args){
//静态初始化:创建+赋值,一旦创建之后,长度不可改变
int[] array1 = {1,2,3,4,14,2};
System.out.println(array1[0]);
//动态初始化,默认初始化
int[] array2 = new int[5];
array2[0] = 10;
System.out.println(array2[0]);
System.out.println(array2[1]);//默认初始化为0
}
}
下标越界及小结
-
数组的四个基本特点
- 长度确定。数组一旦创建,其大小就不可以改变
- 其元素必须是相同类型
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型
- 数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因而数组对象本身是在堆中的
-
数组越界
ArrayIndexOutOfBoundsException
数组的使用
public class Demo01{
public static void main(String[] args){
int[] array = {1,2,3,4,5};
//打印全部的数组元素
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("------");
//计算所有元素的和
int sum=0;
for (int i = 0; i < array.length; i++) {
sum+=array[i];
}
System.out.println(sum);
System.out.println("------");
//查找最大元素
int max=array[0];
for (int i = 1; i < array.length; i++) {
if (array[i]>max)
max=array[i];
}
System.out.println(max);
}
}
public class Demo02 {
public static void main(String[] args) {
int[] array={1,2,4,123,5};
//增强型for循环,取不到下标,一般用作打印输出等操作
for (int a: array) {
System.out.println(a);
}
int[] array2 = reverse(array);
for (int a : array2) {
System.out.println(a);
}
}
//反转数组,数组作参数和返回值
public static int[] reverse(int[] array){
int[] result = new int[array.length];
for (int i=0,j=array.length-1;i<array.length;i++,j--){
result[j] = array[i];
}
return result;
}
}
多维数组
-
多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每个元素都是一个一维数组
-
二维数组 ```int[][] a=new int[2][5];`
-
解析:以上二维数组a可以看成一个两行五列的数组
public class Demo01{
public static void main(String[] args){
//四行两列 array[4][2]
int[][] array = {{1,2},{3,4},{5,6},{7,8}};
for (int[] ints : array) {
System.out.println(ints);
}
System.out.println(array[2][1]);
System.out.println(array[0].length);
}
}
Arrays类
- 数组的工具类java.util.Arrays
- Arrays类中的方法都会static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而不需要使用对象来调用(是"不需要",而不是"不能")
- 具有以下常用功能:
- 给数组赋值:通过fill方法
- 对数组排序:通过sort方法,升序
- 比较数组:通过equals方法比较数组中元素值是否相等
- 查找数组元素:通过binarySearch方法对排序好的数组进行二分查找
import java.util.Arrays;
public class Demo01{
public static void main(String[] args){
int[] a = {1,2,92,3,15,4,55};
System.out.println(a);//[I@1b6d3586
//打印数组元素Arrays.toString()
System.out.println(Arrays.toString(a));//[1, 2, 92, 3, 15, 4, 55]
//对数组元素排序,升序
Arrays.sort(a);
Arrays.fill(a,2,4,0);//数组填充
System.out.println(Arrays.toString(a));
}
}
稀疏数组
- 当一个数组中大部分元素为0,或者为同一个值的数组时,可以用稀疏数组来保存该数组
- 稀疏数组的处理方式
- 记录数组一共有几行几列,有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
public class Demo01{
public static void main(String[] args){
//1.创建一个二维数组 11*11 0:没有棋子 1:黑棋 2:白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//转化为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i=0;i<11;i++){
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0)
sum++;
}
}
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,将非零值放入稀疏数组中
int count = 0; //count起到计数的作用
for (int i = 0; i < array1.length; i++) {
for (int j=0;j<array1[i].length;j++){
if (array1[i][j]!=0){
count++;
array2[count][0]=i;
array2[count][1]=j;
array2[count][2]=array1[i][j];
}
}
}
System.out.println("稀疏数组:");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
}
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原值
for (int i=1;i<array2.length;i++){
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
}
}