JavaSE
前奏
学习方法
记录
多写代码，多些笔记，多写文章
交流，思维，技能
分享，提问(怎么了)，思考(为什么)
坚持
Blog==有效的记忆
总结与思考
文笔组织能力
学习总结能力
逻辑思维能力
帮助他人，结交朋友
冰冻三尺非一日之寒
预科
- 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
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mq5tptfs-1613715044162)(笔记图片/while说明.png)] - 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
方法重写
3、多态
从代码运行的角度来说，先有类再有对象 类是对象的模板
对象，具体的事物。类，抽象的，对对象的抽象。
构造器
- 一个类即使什么都不写，它也会存在一个方法==构造器
- 必须和类的名字相同
- 必须没有返回值，也不能写void
- 用来初始化值
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
