狂神说JavaSE笔记（更新）
JavaSE
前奏
学习方法
记录
多写代码，多些笔记，多写文章
交流，思维，技能
分享，提问(怎么了)，思考(为什么)
坚持
Blog==有效的记忆
总结与思考
文笔组织能力
学习总结能力
逻辑思维能力
帮助他人，结交朋友
冰冻三尺非一日之寒
博客平台----wordpress、typecho
博客园
预科
- io设备
i–>input输入
o–>ouput·输出
- dos命令
环境安装
配置环境变量
1.添加JAVA_HOME–>变量的值=安装路径(bin的上级目录)
2.配置path–>%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin
cmd–>java -version测试是否成功
Hello World
public class Hello{
public static void main(String[] args)
System.out.print("Hello World!");
}
编译–>javac
运行–>java
文件名与类名保持一致
程序运行机制
IDEA安装
IDE–＞集成开发环境
入门
所有的标识符都应该以大小写、$、_开头
命名规则
包名：小写
类名:驼峰 所有单词首字母大写
变量名、方法名:小驼峰 lastNameAge
常量名:大写,中间加_
数据类型
基本数据类型
整数类型
int
byte
short
long–>l
浮点类型
float–>f
double
字符类型
char
String–>不是一个关键字，类
布尔类型
引用数据类型
类
接口
数组
拓展
//整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
int i=10;
int i2=010;//8
int i3=0x10;//16 0~9 A~F
//浮点数拓展
//float 有限的离散的 舍入误差 约数
// 避免浮点数进行比较 BigDecimal数学工具类
//double
float f=0.1f;
double d=1.0/10;
System.out.println(f);
System.out.println(d);
System.out.println(f==d);
//0.1
//0.1
//false
float d1=212114343134431f;
float d2=d1+1;
System.out.println(d1==d2);
//true
//字符类拓展
char c1='a';
char c2='中';
System.out.println((int)c1);
System.out.println((int)c2);
//所有的字符本质都是数字
//编码Unicode 2字节 65536 2 16
//U0000 UFFFF
char c3='\u0061';
System.out.println(c3);
//转义字符
// \n--换行 \t--制表符
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa==sb);
String sc = "hello world";
String sd = "hello world";
System.out.println(sc==sd);
//布尔值拓展
boolean flag = true;
//if (flag==true)与if (flag)是一样的
//Less is More! 代码要精简易读
数据类型转换
byte，short，char–>int–>long–>float–>double
运算前不同数据类型先转化为同一类型
强制转换
从低到高 (数据类型)变量命
自动转换
自动转换
变量
局部变量–>在方法里的
实例变量–>方法的外面，类的里面，从属于对象
public class Day02 {
String name;
int age;
public static void main(String[] args) {
Day02 day02 = new Day02();
System.out.println(day02.age);
}
}
//如果不初始化 数值型 默认值 0 0.0
//布尔默认值是 false
//除了基本类型其余都是 null
类变量 stasic
常量
final 常量名=数值
运算符
++a先运算再赋值
a++先赋值再运算
逻辑运算符
与&&---->两个变量都为true，结果为true；
或||---->两个变量有一个为true，结果为true；
非！---->如果为true则变为false，反之；
//短路运算
int a = 5;
boolean d = (a<4)&&(a++<4);
System.out.println(d);
System.out.println(a);
位运算
//位运算
/*
A = 0011 1100
B = 0000 1101
如果2个都为1才为1，否则为0 A&B = 0000 1100
有一个1就为1 A|B = 0011 1101
相同则为0，不同则为1 A^B = 0011 0001
取反 ~B = 1111 0010
*/
左移<< == *2
右移>> == /2
进制
为了便于理解什么叫2进制，先说说10进制。
我们平时常用的都是10进制，顾名思义，满10进1，
也就是当低位的值够10之后，就在高位上加1，本位变成0。
2进制就是同理，计数时满2进1，
当低位满2之后，就在高位+1，低位变成0。
字符串连接符+
如果+两侧有一侧出现字符串，就会把其他类型都转换成字符串类型连接
注意：运算顺序
int a = 10;
int b = 20;
System.out.println(""+a+b);
System.out.println(a+b+"");
1020
30
条件运算符
? : ----> x ? y : z
如果x为true，则结果为y,否则为z
优先级问题()
import导包
com.baidu.www
流程控制
Scanner
if选择结构
- if
- if……else
- if……else if……else
选择其中的一个执行，然后跳出程序。但是Java的基础结构为顺序结构
if嵌套结构
switch多选择结构
switch(expression)
case value:……
break；
case value:……
break；
case value:……
break；
default:……
循环结构
-
while
-
do…while
do…while循环和while相似，不同的是，do…while循环至少循环一次（先执行再循环，while相反，先判断再循环）
-
增强型for循环
int[] numbers = { 12,55,53,34,88,22}; for (int n:numbers){ System.out.println(n); } //将numbers的值赋给n -
for
实例1：
//for循环输出1-1000之间能被5整除的数，每行显示3个
for (int i = 1 ; i <= 1000; i++) {
if (i % 5 == 0) {
System.out.print(i+" ");
}
if (i%(5*3)==0) {
System.out.println();
}
}
实例2：
//打印九九乘法表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i+"*"+j+"="+(i*j) + "\t");
}
System.out.println();
}
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
//自己的错误示范
for (int i = 1; i <= 1; i++) {
int y = 1;
int sum = y * i;
System.out.println(i+"*"+y+"="+sum);
}
for (int i = 1; i <= 2; i++) {
int e = 2;
int sum = e * i;
System.out.print(i+"*"+e+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 3; i++) {
int s = 3;
int sum = s * i;
System.out.print(i+"*"+s+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 4; i++) {
int si = 4;
int sum = si * i;
System.out.print(i+"*"+si+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 5; i++) {
int wu = 5;
int sum = wu * i;
System.out.print(i+"*"+wu+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 6; i++) {
int l = 6;
int sum = l * i;
System.out.print(i+"*"+l+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 7; i++) {
int q = 7;
int sum = q * i;
System.out.print(i+"*"+q+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 8; i++) {
int b = 8;
int sum = b * i;
System.out.print(i+"*"+b+"="+sum+" ");
}
System.out.println();
for (int i = 1; i <= 9; i++) {
int j = 9;
int sum = j * i;
System.out.print(i+"*"+j+"="+sum+" ");
}
System.out.println();
-
break/continue
break强制退出循环体
continue退出当前循环并且执行下一次循环
练习：
//打印三角形
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
方法
retun可以结束方法
重载
可变参数
只能有一个，必须放在最后
练习：
//自己写的计算器
public class Demo04 {
public double add(double a,double b){
double sum = a + b;
return sum;
}
public double sub(double a,double b){
double sum = a - b;
return sum;
}
public double mul(double a,double b){
double sum = a * b;
return sum;
}
public double div(double a,double b){
double sum = a / b;
return sum;
}
public static void main(String[] args) {
Demo04 mythod = new Demo04();
Scanner scanner = new Scanner(System.in);
for (int i = 1;; i++){
System.out.println("请输入要计算的数字");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
System.out.println("输入计算方法");
String method = scanner.next();
switch (method) {
case "+":
System.out.println(mythod.add(a, b));
break;
case "-":
System.out.println(mythod.sub(a, b));
break;
case "*":
System.out.println(mythod.mul(a, b));
break;
case "/":
System.out.println(mythod.div(a, b));
break;
}
}
}
}
数组
//声明数组
int[] num01;
//创建数组
array = new int[10]
//声明并且创建数组
int[] array = new int[长度];
//赋值
int[] num = {
0,1,2,3,4,5,6,7,8,9};
num[1] = 1;
数组原则
ArrayIndexOutOfBoundsException数组下标越界异常
长度是确定的
数组中类型必须相同
数组中元素可以是任何类型
数组变量属于引用类型，数组可以看作为对象，数组中每个元素相当于对象的成员变量
数组本身就是对象，Java中对象是在堆中的，因此无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组的使用
public class Demo03 {
public static void main(String[] args) {
int[] array = {
1,2,3,4,5,6};
//printArry(array);
int [] reverse = reverse(array);
printArry(reverse);
// for (int i : array) {
// System.out.println(i);
// }
}
//打印数组元素
public static void printArry(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
⭐⭐//反转数组 数组作为返回值
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;
}
}
多维数组
//循环嵌套输出二维数组
int[][] array = {
{
1,2},{
2,3},{
3,4},{
4,5}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+" ");
}
}
//用增强型for循环输出二维数组
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("输出原始棋盘数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
Array类
冒泡排序
八大排序之一
//冒泡排序
public static int[] sort(int[] array) {
int temp = 0;
//外层循环判断程序跑多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较两个数的大小
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;
}
}
}
return array;
}
稀疏数组
public class Demo08 {
public static void main(String[] args) {
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("输出原始棋盘数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
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+"个有效值");
//创建一个稀疏数组
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");
}
//还原稀疏数组
//读取稀疏数组
int[][] array3 =new int[array2[0][0]][array2[0][1]];
//还原值
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();
}
}
}
内存
-
堆：
存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用
-
栈
存放基本的变量类型（包含基本类型的具体数值）
引用对象的变量（存放这个引用在堆里面的具体地址）
-
方法区
可以被所有线程共享
包含了所有的class和static的变量
面向对象编程OOP
特性
本质：以类的方式组织代码，以对象的形式封装数据
抽象 = 共同点
注意：类里面只有属性和方法
从代码运行的角度来说，先有类再有对象 类是对象的模板
对象，具体的事物。类，抽象的，对对象的抽象。
※ 特性：
**1、**封装 private ”高内聚 低耦合“---->类的内部数据操作细节自己完成，仅暴露少量的方法给外部使用
属性私有 get/set
**2、**继承 extends本质是对某一批楼的抽象，从而实现对世界更好的建模(再次抽象)
继承是类与类之间的一种关系（除此之外还有依赖、组合、聚合等），Java中只有单继承没有多继承（一个子类只能有一个父类）
public下，子类继承了父类之后就会有父类的全部方法（也可以用private，需设置公共的方法get/set）
CTRL + H 查看继承树
①object类---->Java中所有的类都之间或间接继承object类
②super
super注意点：
1.super调用父类的构造，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
VS this：
this：本身调用者这个对象
super：代表父类对象的引用
前提
this没有继承也能用
构造方法：
this（）；本类的构造
super（）：父类的构造
③方法重写，和属性无关
B b = new A();//子类重写了父类的方法，只跟非静态有关
总结：前提需要有继承关系，而且是子类重写父类的方法
方法名，参数列表必须相同。方法体不同。
#修饰符 范围可以扩大，不能缩小public>protected>default>private
#抛出的异常：范围可以被缩小，不能被放大
有些方法不能被重写
static 方法属于类不属于实例
final 常量
private方法
**3、**多态
解释：同一个方法可以根据发送对象的不同而采取多种不同的行为方式
多态是方法的多态，属性没有多态。
类型转换异常---->ClassCastException！
多态存在的条件：有继承关系，方法需要重写，父类的引用指向的是子类（Father f1 = new Son();）
一个对象的实际类型是确定的，但是指向的引用类型不确定---->父类的引用指向子类
两个类型都有就执行子类，具体看下方代码。
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了
Student s1 = new Student();//子类可以调用自己的和父类的方法
//父类引用指向子类的类型
Person s2 = new Student();//虽然可以指向子类，但是不能调用子类独有的方法
s2.run();//子类重写了父类的方法就执行子类
s1.run();
//((Student) s2).eat();
s1.eat();
//子类父类都有，只要子类没有重写调用父类
//对象能执行那些方法看左边类型，右边关系不大
}
构造器
- 一个类即使什么都不写，它也会存在一个方法==构造器
- 必须和类的名字相同
- 必须没有返回值，也不能写void，一旦定义了有参构造就必须显示定义无参构造
- 用来初始化值
- new对象的时候会进入构造方法
instanceof
判断两个类型是否存在父子关系
自动转换
低---->高 自动转换 子类转换成父类可能会丢失自己的方法
高---->低 强制转换（）
条件：父类引用指向子类对象
static
如果有static，就用类名访问
如果没有static，就用对象
非静态方法可以访问静态方法
public class Person {
{
//可以赋值初始值，因为和对象同时产生对象
System.out.println("匿名代码块");
}
static {
//静态代码块,只执行一次，其他的，在对象创建时候就会执行。
System.out.println("静态代码块");
}
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("==========");
Person person2 = new Person();
}
}
//被final修饰的量没有子类
抽象类
用abstract修饰类或者方法
//抽象方法，没有方法的实现
//抽象类的所有方法必须要有子类实现
//继承抽象类的子类必须要实现它的方法 重写
//除非子类也是抽象方法
不能new抽象类，只能靠子类实现
抽象类中可以用普通方法
抽象方法必须在抽象类中
接口
接口就是规范
###设计模式=面向对象的精髓
接口中方法默认public abstract
###接口中变量默认public static final
//类可以实现接口
//实现了接口的类必须要重写接口的方法，一个类可以实现多个接口（侧面实现多继承）
//接口同过implements实现
//接口不能被实例化，接口没有构造方法
架构师==抽象的思维
内部类
内部类访问外部类的私有变量
-
静态内部类 无法访问非静态的属性
-
匿名类 一个Java文件中可以有多个class类，但是只能有一个main
-
局部内部类
-
匿名内部类
new.Apple().eat();
异常机制介绍
检查性异常
运行时异常
错误Error
try
catch捕获
catch（想要捕获的异常类型） 最高的Throwable
finally
throw 在方法里主动抛出异常
throws 在方法上抛出异常
异常要从小到大
快捷键CTRL+ALT+T