- 简单性
- 面向对象
- 可移植性
- 高性能
- 分布式
- 动态性
- 多线程
- 安全性
- 健壮性
java比较倾向于服务器
JavaSE:标准版 ——————本文学习对象
JavaME:嵌入式开发
JavaEE: E企业级开发（web端，服务器开发…）
JDK 、JRE、JVMJDK 包含 JRE 包含 JVM
java基础-
注释
- 单行注释 // 注释内容 Ctrl + /
- 多行注释
- javadoc文档注释
-
标识符
- java所有的组成部分都需要名字。类名、变量名以及方法名都称为标识符
- 常见标识符（后面补充）
-
- 命名规则
- 所有标识符都应该以字母（A-Z或a-z）,美元符号$,或下划_开始
- 后面的随意
-
数据类型
-
强类型语言(java)
-
要求变量的使用严格符合规定，所有变量都必须先定义后才能使用
未定义前：
public class Demo{ public static void main(String[] args){ String a; System.out.println(a); } }定义后：
public class Demo{ public static void main(String[] args){ String a = "10"; System.out.println(a); } } -
特点
- 安全性
- 但是运行速度就变慢了
-
-
弱类型语言（js）
- 运行速度快
-
Java的数据类型分为两大类型
-
基本类型
- 数值类型：
- 整数类型
- byte占1个字节范围：-128-127
- short占2个字节范围：-32768-32767
- int占4个字节范围：-2147483648-2147483647
- long占8个字节范围：-9223372036854775808-9223372036854775807
- 浮点类型
- float占4个字节
- double占8个字符
- 字符类型
- char占2个字节
- 整数类型
- Boolean类型：
- 占1位其值只有true和false两个
public class Demo02{ public static void main(String[] args){ //八大基本数据类型 int num1 = 10; //最常用 byte num2 = 20; short num3; long num4 = 30l; //Long类型要在数字后面加个L //小数：浮点数 float num5 = 50.1F; //float类型要在数字后面加个F double num6 = 3.141595546688855446488; //字符 char name = '哈哈' //字符串，String不是关键字，类 //布尔值：是非 boolean flag = true; } }
- 数值类型：
-
引用类型
- 类
- 接口
- 数组
-
-
数据类型拓展
public class Demo { public static void main(String[] args){ //整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x int i = 10; int i2 = 010; //八进制 int i3 = 0x10; //十六进制0x //浮点数拓展？ 银行业务怎么表示？钱 //最好用BigDecimal 数学工具类 //字符拓展？ //所有的字符本质还是数字 //转义字符 // t 制表符号 // n 换行 //。。。。。（自己总结） //布尔值扩展 boolean flag = true; if (flag == true){} //新手 if (flag){} //老手 //less is more！代码要精简易读 } } -
类型转换
-
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
-
低--------------------------------------------------》高
byte,short,char,int,long,float,double
-
-
public class Demo{ public static void main(String[] args) int i = 128; double b = i; //强行转换 （类型）变量名 高--低 //自动转换 低--高 }
-
-
-
变量
-
变量是什么：就是开业变化的量！
-
java是一种强类型语言，每个变量都必须声明其类型。
-
java变量是程序中最基础的存储单位，其要素包括变量名，变量类型和作用域。
type varName [=value][,{varName[=value]}]; //数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变- 注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明式一条完整的语句，因此每个声明都必须以分号结束。
public class Staty01 { public static void main(String[] args) { //基本类型 //int a,b,c; 不建议这样写 //int a=1, b=2,c=3; 不建议这样写,程序可读性 int a = 1; //建议这样写 //引用类型 String name = "hello world";}
}
- 注意事项
-
变量作用域
-
类变量
-
实例变量
-
局部变量
public class Staty01 { //类变量 static static double salary =2500; //属性：变量 //实例变量：从属于对象，不需要声明初始值；如果不自行初始化，这个类型的默认值0 0.0 //布尔值：默认是false //除了基本类型，其余的默认值都是null； String name; //null int age; //0 //主程序方法，现在都是叫main方法 public static void main(String[] args) { //1、局部变量;必须声明和初始化值，只在{}内 //没有声明前 //int i ; //System.out.println(i); //声明后 int i = 10 ; System.out.println(i); //实例变量 //变量类型 变量名字 = new Staty01(); Staty01 staty01 = new Staty01(); System.out.println(staty01.age); System.out.println(staty01.name); //类变量 static System.out.println(salary); } //其他方法 public void add(){ } } -
常量
-
常量：初始化后不能再改变的值！不会变动的值。
-
所谓的常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
-
常量名一般使用大写字符。
public class Staty01 { //常用在固定的参数 //修饰符，不存在先后顺序,一般用大写 static final double PI = 3.14; public static void main(String[] args){ System.out.println(PI); } } -
变量的命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：mouthSalary
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线
- 类名：首字母小写和驼峰原则
- 方法名：首字母小写和驼峰原则
-
-
-
-
基本运算符
-
java语言支持如下运算符：
-
算术运算符：+，—，*，/，%，++，——
-
赋值运算符：=
-
关系运算符：>,<，>=，<=，==，!=instanceof
-
逻辑运行符：&&，||，！（与、或、非）
熟悉以上几种即可
-
位置算符：&，|，^，~，>>，<<，>>>（了解！）
-
条件运算符？：
-
扩展赋值运算符：+=，-=,*=,/=
public class Staty01 { public static void main(String[] args) { //二元运算符 int a = 10; int b = 20; int c = 30; int d = 40; System.out.println(a+b); System.out.println(a-b); System.out.println(a*b); //System.out.println(a/b); 在除成小数的时候需要，进行类型转换，比如int转double（得bou） System.out.println(a/(double)b); } }//cast：转换 public class Staty01 { public static void main(String[] args) { long a =2158888444L; int b = 112; short c = 10; byte d = 8; System.out.println(a+b+c+d);//long System.out.println(b+c+d);//int System.out.println(c+d);//int //如果有long相加结果都为long //除开long如果有int相加结果都为int } }public class Staty01 { public static void main(String[] args) { //关系运算符返回得结果:正确，错误 布尔值 //if int a = 10; int b = 20; int c = 21; System.out.println(c%a); //c /a 20 / 10 = 2.....1 System.out.println(a>b); System.out.println(a -
-
-
自增自减运算符、初识Math类
public class Staty01 { public static void main(String[] args) { //++ -- 自增，自减 一元运算符 int a = 3; int b = a++; //执行完成这行代码后，先给b赋值，再自增 //a = a + 1； System.out.println(a); //a = a + 1； int c = ++a; //执行完成这行代码前，先自增，再给b赋值 System.out.println(a); System.out.println(b); System.out.println(c); //幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具类来操作！ //Math 提供了科学运算得方法 double pow = Math.pow(3,2); System.out.println(pow); } } -
逻辑与运算
public class Staty01 { public static void main(String[] args) { // 与（and） 或（or） 非（取反） boolean a = true; boolean b = false; System.out.println("a&&b: " + (a && b)); //逻辑与运算：两个变量都为真，结果猜才为true System.out.println("a||b: " + (a || b)); //逻辑与运算：两个变量有一个为真，结果猜才为true System.out.println("!(a&&b): " + !(a && b)); //逻辑与运算：如果是真，则变假，如果是假则变真 //短路运算 可以通过代码运行的先后去理解 int c = 5; boolean d = (c < 4) && (c++ < 4); System.out.println(d); System.out.println(c); } } -
位运算
public class Staty01 { public static void main(String[] args) { System.out.println(2<<3); } } -
扩展赋值运算符和条件运算符（三元运算符）
public class Staty01 { 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 System.out.println(""+a+b); System.out.println(a+b+""); } }条件运算符（三元运算符）
public class Staty01 { public static void main(String[] args) { // X ？ y ：z //如果x == true ，则结果为y，否则结果为z int score = 50; String type = score < 60 ?"不及格":"及格"; //必须掌握 //是等同if的一个方法 System.out.println(type); } } -
包机制(本质是文件夹)
-
目的：
为了更好地组织类，Java提供了包制止，用于区别类名的命名空间。
-
包语句语法格式为：
package pkg1[.pkg2[.pkg3...]];
-
一般利用公司域名倒置作为包名；www.baidu.com com.baidu.www
-
为了能够使用某一个包的成员，我们需要在Java程序中明确导入包。使用“import”语句可以完成此功能
import package1[.package1....]....;
-
Java Doc
javadoc命令自动生成自己的api文档
//当前文档下 javadoc -encoding UTF-8 -charset UTF-8 Doc.java
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
-
Java流程控制
-
Scanner对象
-
scanner类来获取用户的输入
-
Scanner s = new Scanner(System.in);
-
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般使用hasNNext()与hasNextLine()判断是否还有输入的数据。
-
next();
空格为结束
import java.util.Scanner; 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流的类如果不关闭会一直占用资源，要成好习惯用完就关掉 //IO流:输入输出 scanner.close(); } } -
nextLine():
Enter为结束
import java.util.Scanner; public class Demo01 { public static void main(String[] args) { //创建一个扫描器对象，用于接收键盘数据 Scanner scanner = new Scanner(System.in); System.out.println("使用nextLine方法接收:"); //判断用户有没有输入字符串 if (scanner.hasNextLine()){ //使用next方式接收 String str = scanner.nextLine(); System.out.println("输出内容："+str); } //凡是输入IO流的类如果不关闭会一直占用资源，要成好习惯用完就关掉 //IO流:输入输出 scanner.close(); } }
-
-
scanner 进阶
import java.util.Scanner; public class Demo01 { public static void main(String[] args) { //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果； Scanner scanner = new Scanner(System.in); //和 double sum = 0; //计算输入了多少数字 int m = 0; //通过循环判断是否还有输入，并在里面对每一次进行求和统计 //默认是真 while (scanner.hasNextDouble()){ double x = scanner.nextDouble(); m = m + 1; //m++ sum = sum + x; System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum); } System.out.println(m + "个数的和为"+sum); System.out.println(m + "个数的平均值是"+(sum / m)); scanner.close(); } } -
顺序结构
-
java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
-
顺序结构是最简单的算法结构。
-
语句与语句之间，框与框之间是按照从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的基本算法结构。
public class Demo01 { public static void main(String[] args) { System.out.println("hello1"); System.out.println("hello2"); System.out.println("hello3"); System.out.println("hello4"); } }
-
-
选择结构
-
if单选择结构
import java.util.Scanner; public class Demo01 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入内容："); String s = scanner.nextLine(); //equals:判断字符串是否相等 if (s.equals("hello")) { System.out.println(s); } System.out.println("End"); scanner.close(); } } -
if双选择结构
if else
-
if多选择结构
if else if else
-
嵌套的if结构
-
switch多选择结构
-
-
37——43没有看
- Java方法
- 什么是方法
- System.out.println(),那它是什么呢？
System 类 out对象 println()方法
//一、第1步
//public class Demo01 {
// //main方法，void表示方法值为空值
// public static void main(String[] args) {
//
// }
//
// //加法,因为这里写了方法类型是int，所以必须要return返回
//加入static使方法变成类变量，可以进行调用
// public static int add(int a, int b) {
// return a + b;
// }
//}
//一、第2步，调用方法
public class Demo01 {
//main方法，void表示方法值为空值
public static void main(String[] args) {
int sum = add(1, 2);
System.out.println(sum);
}
//加法,因为这里写了方法类型是int，所以必须要return返回
public static int add(int a, int b) {
return a + b;
}
}
-
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期扩展
-
注意：main方法要时刻保持简洁和干净
-
方法的定义
-
java的方法类似于其他语言的函数，是一段用来完成特定功能的代码段，一般情况下，定义一个方法包含以下语法：
-
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
-
修饰符：可选的
-
返回值类型：可能有，如：return Value Type
-
方法名：驼峰型
-
参数类型：参数像一个占位符
- 形式参数
- 实参
-
方法体
public class Demo01 { //main方法，void表示方法值为空值 public static void main(String[] args) { //add(1, 2)实际参数：实际调用传递给他的参数 int sum = add(1, 2); System.out.println(sum); } //加法,因为这里写了方法类型是int，所以必须要return返回 //add(int a, int b)形式参数，用来定义作用的 public static int add(int a, int b) { return a + b; } }
-
???值传递（java）和引用传递
-
方法的重载
- 重载就是在一个类中，有相同的函数名称，但形参不同的函数。
- 方法的重载规则：
- 方法名称必须相同。
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。如：一个是doule 一个是int
- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载。
- 实现理论：
- 方法名称相同时，编译器回根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错
-
命令行传参
- java com******* ******
-
可变参数（不定向参数）
-
JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
-
在方法声明中，指定参数类型后加一个省略号（…）。
-
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class Demo01 { public static void main(String[] args) { Demo01 demo01 = new Demo01(); demo01.test(12,2,3); } public void test(int x, int...i){ } }
-
-
递归(基数小的时候可以使用，如果不是建议不要使用)
- A方法调用B方法，我们很容易理解！
- 递归就是：A方法调用A方法！就是自己调用自己
- 递归结构包含两部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体：什么时候调用自身方法。
- 5！ 5 * 4 * 3 * 2 * 1
- 5*f(4)
-
- 数组（最简单的数据结构）
-
数组概述
- 数组是相同类型数据的有序集合。
- 数组描述是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称作一个数组元素，每个数组可以通过一个下标来访问他们
-
数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组。下面声明数组变量的语法：
dataType[ ] arrayRefVar；//首选方法 dataType arrayRefVar[ ] ；//效果相同。但是不是首选方法
-
java语言使用new操作来创建数组，语法如下：
dataType[ ] arrayRefVar = new dataType[arraySize]；
-
数组的元素是通过索引访问的，数组索引从开始。
-
获取数组长度：arrays.length
public class Demo01 { public static void main(String[] args) { int[] nums;//1.声明一个数组 nums = new int[10];//2.创建一个数组 //3.给数组元素中赋值 nums[0] = 1; nums[1] = 2; nums[2] = 3; nums[3] = 4; nums[4] = 5; nums[5] = 6; nums[6] = 7; nums[7] = 8; nums[8] = 9; nums[9] = 10; //如果不赋值，则直接返回0 System.out.println(nums.length); //计算所有元素的和 int sum = 0; //获取数组长度：array.length for (int i = 0; i < nums.length; i++) { sum = sum + nums[i]; System.out.println("总和"+sum); } } }备注：
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
-
内存分析
- Java内存
- 堆：
- 存new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
- 栈
- 存放基本变量类型
- 引用对象的变量
- 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量、
- 堆：
- 声明数组的时候，内存并不存
- 创建数组的时候才存在，给予赋值的时候才有值，否则是默认元素
- Java内存
-
三元初始化
-
静态初始化
-
动态初始化
-
数组的默认初始化
- 数组是引用类型，它的元素相当于类的实力变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
public class Demo01 { public static void main(String[] args) { //静态方法 int[] a= {1,2,3,4,5}; System.out.println(a[0]); //动态初始化:包含默认初始化 int[]b = new int[10]; b[0] = 10; b[1] = 10; //不赋值时，int默认为0，str为null System.out.println(b[0]); System.out.println(b[1]); System.out.println(b[2]); } }备注：数组是一个对象，对象是在堆中的，数组内只能是同个类型
-
-
-
数组使用
-
基本用法
public class Demo01 { public static void main(String[] args) { int [] arrays = {1,2,3,4,5}; //打印全部的数组元素 for (int i = 0; i < arrays.length; i++) { System.out.println(arrays[i]); } System.out.println("========="); //计算所有元素的和 int sum = 0; for (int i = 0; i < arrays.length; i++) { sum += arrays[i]; } System.out.println("sum="+sum); System.out.println("======="); //查询最大元素 int max = arrays[0]; for (int i = 0; i < arrays.length; i++) { if (arrays[i]>max){ max = arrays[i]; } } System.out.println("max="+max); } } -
进阶用法
public class Demo01 { public static void main(String[] args) { int[] arrays = {1,2,3,4,5}; //JDK1.5 没有下标 // for (int array:arrays){ // System.out.println(array); 打印数组元素，main方法内调用printArray // printArray(arrays); //反转数组 int[] reverse = reverse(arrays); 打印反转数组，main方法内调用printArray printArray(reverse); } //反转数组 public static int[] reverse(int[]arrays){ int[] result = new int[arrays.length]; //反转操作 for (int i = 0,j= result.length-1; i < arrays.length ; i++,j--) { result[j]=arrays[i]; } return result; } //打印数组元素 public static void printArray(int[] arrays){ for (int i = 0; i < arrays.length; i++) { System.out.println(arrays[i]+""); } } } //不明白就debug
-
-
-
多维数据
-
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组
-
二维数组 P56
int a[][] = new int[2][5];
-
解析：以上二维数组a可以看成一个两行5列的数组
public class Demo01 { public static void main(String[] args) { int [][] array = {{1,2},{3,4},{5,6},{7,8}}; System.out.println(array[2][0]); System.out.println(array[2][1]); } }
-
-
Arrays类（操作数组的类）
- 数组的工具类Java.util.Arrays
- 由于数组对象本身并没有什么方法可以提供我们调用，但API中提供例如一个工具类Arrays供我们用，从而可以对数据对象进行一些基本的操作。
- 查看JDK帮助文档
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）
- 具有以下常用功能：
- 给数组赋值：通过fill方法。
- 对数组排序：通过sort方法，按升序。
- 比较数组：通过equals方法比较数组中元素值是否相等。
- 查找数组元素：通过binarySearch方法能对排序号的数组进行二分查找法操作。
- structur 英[ˈstrʌktʃə®] 结构
-
冒泡排序
-
冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！
-
冒泡的代码还是相当简单的，两层循环，外层冒泡数，里层依次比较
-
我们看到嵌套循环，应该立马就可以得到这个算法得时间复杂度为O(n2)。
import java.util.Arrays; public class Demo01 { public static void main(String[] args) { int [] a ={1,4,5,6,7,10,1}; int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组 System.out.println(Arrays.toString(sort)); } //冒泡排序 //1.比较数组中，两个相邻得元素，如果第一个数比第二个数大，我们就交换他们的位置 //2.每一次比较，都会产生出一个最大，或者最小的数字； //3.下一轮则可以少一次排序！ //4.依次循环，直到结束！ public static int[] sort(int[] array){ //定义临时变量 int temp = 0; //外层循环，判断我们这个要走多少次； for (int i = 0; i < array.length-1; i++) { //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置 boolean flag = false; //通过flag标识减少没有意义的比较 for (int j = 0; j < array.length-1; j++) { if (array [j + 1]>array[j]){ temp = array[j]; array[j] = array [j + 1]; array[j+1] = temp; flag = true; } } if (flag==false){ break; } } return array; } }
-
-
稀疏数组（压缩数组，可以减少内存等）扩展
-
当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
-
import java.util.Arrays; 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]=1; //输出原始的数组 System.out.println("输出原始的数组"); for (int[]ints:array1){ for(int anInt:ints){ System.out.print(anInt+"t"); } System.out.println(); } //转换为稀疏数组保存 //获取有效值的个数 int sum = 0; for (int i = 0; i < 11; i++) { for (int j = 0; j < 11; j++) { if (array1[i][j]!=0){ sum++; } } } System.out.println("有效值的个数:"+sum); //2.创建一个稀疏数组的数组 int[][]array2=new int[sum+1][3]; array2[0][0]=11; array2[0][1]=11; array2[0][2]=sum; //遍历二维数组，将非零的值，存放稀疏数组中 int count = 0; 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"); } System.out.println("========================"); System.out.println("还原"); //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]; } //打印 System.out.println("输出原始的数组"); for (int[]ints:array3){ for(int anInt:ints){ System.out.print(anInt+"t"); } System.out.println(); } } }
-
- psvm 定义一个main方法
- sout 打印
- Ctrl + D 复制当前行，到下一行
- Alt + Enter 自动解决问题
- debug : F7下一步
