2-ts快速学习
前端21 分钟 读完 (大约 3177 个字)

2-ts快速学习

接口、类、函数、泛型

1.接口 “：”

接口是一系列抽象方法的声明，是一些方法特征的集合，是为这些类型命名和为你的代码或第三方代码定义契约。

通俗的说定义类型。

1）基本用法

例如，一个函数接收某个对象User作为参数，我们需要描述其类型，但它不是基本类型，这时候就需要用接口interface来描述这个类型。

1
2
3
4
5
6
7
interface User {
    name: string
    age: number
    isMale: boolean
}

const getUserName = (user: User) => user.name

上面这种写法只检查user的结构及属性的类型（不检查顺序）。

阅读更多
1.ts快速学习
前端11 分钟 读完 (大约 1589 个字)

1.ts快速学习

1.环境搭建

1）安装ts

1
2
3
4
5
6
7
8
9
10
npm install -g typeScript

mkdir ts-study && cd ts-study

mkdir src && touch src/index.ts

npm init

tsc --init
(初始化配置，生成tsconfig.json配置ts文件)
阅读更多
css属性之position:sticky
前端3 分钟 读完 (大约 453 个字)

css属性之position:sticky

回顾position属性其它内容

position一共5中定位方式，即static，relative，absolute，fixed，sticky。

static：默认位置，正常流，元素不重叠。
relative：配合top、bottom、left、right，相对该元素默认位置static进行偏移。
absolute：配合top、bottom、left、right，相对于不为static的父级元素。
fixed：配合top、bottom、left、right，相对于视口(viewport，浏览器窗口)。

阅读更多
初识Java
后端3 分钟 读完 (大约 479 个字)

初识Java

1. 简介

Java是跨平台语言，运行在虚拟机JVM上，JVM又运行在相应的系统上。
开发我们需要先安装JDK（java delelopment kit），即Java开发工具包，其中包括了JVM，也包括了JRE（java runtime environment）Java运行环境。

JavaSE: 标准版，定义了Java的基本语法。
JavaME：移动版，现已基本不用，用在GPS导航、机顶盒、塞班系统等。
JavaEE: 企业版，如用JavaWeb开发企业级B/S架构应用。

阅读更多
vue的插槽
前端3 分钟 读完 (大约 378 个字)

vue的插槽

1. v-slot

vue插槽有两种：具名插槽和作用域插槽，2.6.0以后，使用新语法v-slot指令（缩写为#）将两种语法统一起来。

老旧的语法，这里不再赘述，参见vue官网。下面讲讲新语法的用法。

阅读更多
hexo使用说明
后端12 分钟 读完 (大约 1726 个字)

Java-4流程控制

流程控制：

程序需要根据不同的条件去进行不同的流程处理，在程序中我们称之为流程控制。
举例：用户输入4位卡号，每位数字之和大于20，中奖，小于20则不中奖。

if

语法：
if(判断条件){
//条件成立
}else{
//条件不成立
}

if-esle是Java中最基本的流程控制语句
if后面必须跟(条件)
else后面不能有(),可以直接跟{}
也可以再跟一个if()
else{}可以继续嵌套if语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 学校举办运动会，百米赛跑成绩13秒以内有资格进入决赛，根据性别分别进入男子组和女子组。
public class Test3 {
	public static void main(String[] args) {
		System.out.println("请输入张三的百米成绩");
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println("请输入张三的性别");
		String gender = scanner.next();

		if(score<13) {
			if(gender.equals("男")) {
				System.out.println("进入男子组");
			}else {
				System.out.println("进入女子组");
			}
		}else {
			System.out.println("很遗憾，你被淘汰了！！！");
		}
		
	}
}

String类型的值比较是否相等
不能用 ==
应该用equals方法进行判断

switch case

语法：
switch(要判断的变量){
case 特定值1:
//
case 特定值2:
//
…
}
switch-case和if-else的区别是
switch-case只能处理等值判断，不能处理大于/小于判断
if-else任何判断都可以处理

如果变量满足某个case语句，
则会执行该语句的逻辑代码，同时
该case之后的所有case不再做判断，
统一认为全部满足，逻辑代码都会执行。

如何解决：
在每一个case的逻辑代码结束之后，添加break;

switch支持的数据类型：
int，short，byte，char
枚举类型，String类型 (jdk1.7之后的版本支持)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Test4 {
	public static void main(String[] args) {
		System.out.println("请输入一个数字");
		Scanner scanner = new Scanner(System.in);
		String str = "";
		switch(str) {
			case "1":
				System.out.println("中了一个三等奖");
				break;
			case "20":
				System.out.println("中了二等奖");
				break;
			case "30":
				System.out.println("中了一等奖");
				break;
			default:
				System.out.println("很遗憾，您没有中奖！");
				break;
		}
		
	}
}

循环

for
foreach：增强型for循环
while
do-while

语法：

for:
for(初始化循环变量;循环条件;更新循环变量){
循环体;
}

while:
初始化循环变量;
while(循环条件){
循环体;
更新循环变量;
}

do-while:
初始化循环变量;
do{
循环体;
更新循环变量;
}while(循环条件);

while和do-while的区别

while循环先判断，再执行。
do-while先执行，再判断。
while有可能一次都不执行。
do-while至少会执行一次。

for循环和while（do-while）的区别：

for适用于次数确定的循环
while，do-while适用于次数不确定的循环

循环四要素：

1.初始化循环变量；
2.循环条件；
3.迭代：更新循环变量；
4.循环体；

首先执行初始化循环变量，只执行一次。
判断循环条件是否成立，如果成立，执行循环体，
如果不成立，进行下一次循环，多次执行。
更新循环变量，多次执行。
循环体，多次执行

1
2
3
4
5
6
7
public class Test5 {
	public static void main(String[] args) {
		for(int i = 1;i <= 10000;i++) {
			System.out.println(i+":Hello World");
		}
	}
}

🌰

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// 1.循环输入张三考试的五门成绩，分别打印输出，并且计算平均分。
import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		float score1 = 0.0f;
		float score2 = 0.0f;
		float score3 = 0.0f;
		float score4 = 0.0f;
		float score5 = 0.0f;
		for(int i = 1; i <= 5; i++) {
			System.out.print("请输入张三的第"+i+"门成绩:");
			switch(i) {
				case 1:
					score1 = scanner.nextFloat();
				break;
				case 2:
					score2 = scanner.nextFloat();
				break;
				case 3:
					score3 = scanner.nextFloat();
				break;
				case 4:
					score4 = scanner.nextFloat();
				break;
				case 5:
					score5 = scanner.nextFloat();
				break;
			}
		}
		System.out.println("张三的第1门成绩："+score1);
		System.out.println("张三的第2门成绩："+score2);
		System.out.println("张三的第3门成绩："+score3);
		System.out.println("张三的第4门成绩："+score4);
		System.out.println("张三的第5门成绩："+score5);
		System.out.println("张三的平均成绩是"+(score1+score2+score3+score4+score5)/5);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 2.任意输入一个整数：6
// 打印如下的加法表：
// 0 + 6 = 6
// 1 + 5 = 6
// 2 + 4 = 6
// 3 + 3 = 6
// 4 + 2 = 6
// 5 + 1 = 6
// 6 + 0 = 6

import java.util.Scanner;

public class Test4 {
	public static void main(String[] args) {
		System.out.print("请输入一个整数：");
		Scanner scanner = new Scanner(System.in);
		int num = scanner.nextInt();
		for(int i = 0; i < num+1; i++) {
			System.out.println(i + "+" + (num-i) + "=" + num);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 3.打印：如下图形
//     *****
//    *****
//   *****
//  *****
// *****

public class Test7 {
	public static void main(String[] args) {
		for(int j = 0; j < 5; j++) {
			//输出空格
			for(int i = 0; i < 4 - j; i++) {
				System.out.print(" ");
			}
			System.out.println("*****");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 4.打印如下图形
//              i     空格    *
//     *        0     4      1  
//    ***       1     3      3
//   *****      2     2      5
//  *******     3     1      7
// *********    4     0      9

public class Test8 {
	public static void main(String[] args) {
		for(int i = 0 ;i < 5; i++) {
			//输出空格
			for(int j = 0; j < 4-i; j++) {
				System.out.print(" ");
			}
			//输出*
			for(int k = 0; k < 2*i+1; k++) {
				System.out.print("*");
			}
			//输出空格
			for(int j = 0; j < 4-i; j++) {
				System.out.print(" ");
			}
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// 5.打印如下图形
//     *        
//    ***       
//   *****      
//  *******     
// ********* 
//  ******* 
//   ***** 
//    ***    
//     *

public class Test9 {
	public static void main(String[] args) {
		//上半部分
		for(int i = 0 ;i < 5; i++) {
			//输出空格
			for(int j = 0; j < 4-i; j++) {
				System.out.print(" ");
			}
			//输出*
			for(int k = 0; k < 2*i+1; k++) {
				System.out.print("*");
			}
			//输出空格
			for(int j = 0; j < 4-i; j++) {
				System.out.print(" ");
			}
			System.out.println();
		}
		
		//下半部分
		for(int i = 0 ;i < 4; i++) {
			//输出空格
			for(int j = 0; j < i+1; j++) {
				System.out.print(" ");
			}
			//输出*
			for(int k = 0; k < 7-2*i; k++) {
				System.out.print("*");
			}
			//输出空格
			for(int m = 0; m < i+1; m++) {
				System.out.print(" ");
			}
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 6.输出9*9乘法口诀表
// 1*1 = 1
// 2*1 = 2 2*2 = 4
// 3*1 = 3 3*2 = 6 3*3 = 9
// ...

public class Test10 {
	public static void main(String[] args) {
		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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// 7.循环输入张三考试的五门成绩，分别打印输出，并且计算平均分，如果操作不当，输入了负数，停止录入并提示错误。
import java.util.Scanner;

public class Test11 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		float score1 = 0.0f;
		float score2 = 0.0f;
		float score3 = 0.0f;
		float score4 = 0.0f;
		float score5 = 0.0f;
		//用户是否输入了负数
		boolean flag = false;
		for(int i = 1; i <= 5; i++) {
			System.out.print("请输入张三的第"+i+"门成绩:");
			float score = scanner.nextFloat();
			//如果输入的成绩<0，则跳出循环
			if(score < 0) {
				flag = true;
        // 当程序执行break时，直接停止当前循环，break之后的代码,不再执行;同时跳出整个循环体，不再执行后续的循环。
				break;
			}
			switch(i) {
				case 1:
					score1 = score;
				break;
				case 2:
					score2 = score;
				break;
				case 3:
					score3 = score;
				break;
				case 4:
					score4 = score;
				break;
				case 5:
					score5 = score;
				break;
			}
		}
		if(flag) {
			System.out.println("您输入有误！请重新输入");
		}else {
			System.out.println("张三的第1门成绩："+score1);
			System.out.println("张三的第2门成绩："+score2);
			System.out.println("张三的第3门成绩："+score3);
			System.out.println("张三的第4门成绩："+score4);
			System.out.println("张三的第5门成绩："+score5);
			System.out.println("张三的平均成绩是"+(score1+score2+score3+score4+score5)/5);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 8.计算1-10之间的整数之和，如果得到的累加值大于30，则停止循环，返回当前累加值。
public class Test12 {
	public static void main(String[] args) {
		int sum = 0;
		for(int i = 1; i <= 10; i++) {
			sum += i;
			if(sum > 30) {
				sum -= i;
				break;
			}
		}
		System.out.println(sum);
	}
}
后端9 分钟 读完 (大约 1336 个字)

Java-3.运算符

常量

Java中值不能被修改的变量叫做常量
final float PI = 3.14f;
常量的名称全部大写（非必须的）

运算符：

1.赋值运算符 = ：将=右边的值赋给左边

2.算术运算符

1）基本算术运算符：+，-，*，/，%，++，–

+，-，*，/，%:都是需要两个操作数来参与运算
++,--:只需要一个操作数参与运算
++放在操作数左边，表示先执行+1运算，再使用操作数
++放在操作数右边，表示先使用操作数，再执行+1运算。
--同理。

2）复合算术运算符：需要两个操作数来参与运算

+=,-=,*=,/=,%=,==,!=

数据类型转换：只适用于数值类型的变量

1.自动类型转换

等号右边的数据可以自动转为等号左边的数据，完成赋值：
如果等号右边的数据范围小于等号左边，则可以完成自动类型转换。

例如，short赋值给int。

2.强制类型转换

如果等号右边的数据范围大于等号左边，则需要使用强制类型转换。

语法：(要转换的类型)目标值
会造成精度损失,例如int赋值给short。

1
2
3
4
5
6
7
public class Test {
  public static void main (String[] args) {
    float num = 9.3f
    int n = (int)num
    System.out.println(n)
  }
}

Demo：

让用户通过键盘输入4位数字的卡号，
求出4位卡号的每一个位数上的数字，打印输出，
并且求这4个数字的总和。

包：package
为了区分同名的Java类而存在的

使用工具类Scanner 类，让用户可以通过键盘输入数字，并且让Java程序接收到这个数字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;

public class MyTest {
	public static void main(String[] args) {
		System.out.println("请您输入4位卡号");
		//创建Scanner工具类对象
		Scanner scanner = new Scanner(System.in);
		int cardId = scanner.nextInt();
		int firstNum = cardId/1000;
		int secondNum = cardId%1000/100;
		int thirdNum = cardId%100/10;
		int forthNum = cardId%10;
		System.out.println("用户输入的数字是："+cardId);
		System.out.println("千位数是："+firstNum);
		System.out.println("百位数是："+secondNum);
		System.out.println("十位数是："+thirdNum);
		System.out.println("个位数是："+forthNum);
		System.out.println("各个位的数字总和是："+(firstNum+secondNum+thirdNum+forthNum));
		/**
		 * 如果数字之和大于20，则该用户中奖，否则不中奖
		 * 我需要得到一个结果，用户中奖或不中奖，结果是由数字之和是否大于20来决定
		 */
		int sum = firstNum+secondNum+thirdNum+forthNum;
		String result = sum>20?"恭喜您中奖啦！！！":"对不起，您没有中奖";
		System.out.println(result);
	}
}

运算符：

1.算术运算符
2.赋值运算符 =
3.关系运算符
4.逻辑运算符
5.条件运算符
6.位运算符

关系运算符：

判断一个表达式是否成立，结果只有两种：成立/不成立，boolean:true/false
==:判断==两边的操作数是否相等。
!=:判断不相等
只有== !=可以作用于任意的数据类型，其他的关系运算符只能作用于数值类型（整型，浮点型 byte,short,int,long,float,double）

<

=
<=

逻辑运算符：

多个表达式之间的逻辑判断
&：与，&左右两边的表达式必须同时成立，结果为true，否则为false
|：或，|左右两边的表达式只要有一个成立，结果为true，|左右两边的表达式都不成立，结果为false
!：非，!右边的表达式成立，结果为false，!右边的表达式不成立，结果为true
&&：短路与
同&
&&左边的结果为false，则不会执行&&右边的表达式
||：短路或
同|
||左边的结果为true，则不会执行||右边的表达式

条件运算符：三元表达式，三目表达式，是用来给变量赋值的

语法：
数据类型 变量名 = 条件?数据1:数据2;
规则：条件成立，表达式1的结果赋给变量，
条件不成立，表达式2的结果赋给变量。

位运算符：对表达式以二进制为单位进行运算

任何进制的数通过除以K反向取余将其转化为k进制数。

十进制转为二进制：

用数字除以2，求出余数，记做第一位，对商继续除以2，求出余数，记做第二位...
直到商为零。

10:1010
9:1001
17:10001

二进制转为十进制：

从右边起，该位的数值乘以该位的权重（2的该位顺序-1次方），依次累加。

1010:10
1001:9
10001:17

位运算

&按位与：将两个操作数转为二进制，每一位进行运算，两个数都为1，则该位记为1。
|按位或：将两个操作数转为二进制，每一位进行运算，两个数中有一个为1，则该位记为1。
^按位异或：将两个操作数转为二进制，每一位进行运算，两个数不一样，则该位记为1。
<<左移
a<<b 即a*(2^b)

右移
a>>b 即a/(2^b)

如果参与运算的操作数是表达式，则&，|是与和或
如果参与运算的操作数是数值，则&，|是按位与或按位或

后端4 分钟 读完 (大约 623 个字)

Java-2.变量

Java的代码规范：

1.文件名与类名必须一致（必须要遵守）
2.类名的首字母大写（非必须）
3.main()是程序的入口，四要素必不可少(必须的)
public static void main(String[] args)
4.{}成对出现，缺一不可（必须的）
5.一行只写一条语句（非必须）
6.代码缩进（非必须）

注释：

程序不会加载注释的内容，为了让别人看懂你的代码，相当于我们对
代码的解释。

单行注释//
多行注释/**

/
多行注释/*
*
*
*
*/

println：会自动换行
print：不会自动换行
通过转义字符也可以实现自动换行
\n:自动换行
\t:打印一个制表符，8个空格

变量

计算机中保存数据的地方叫内存，不同的数据存入不同的内存，
彼此之间是相互独立的。

每一块内存都有一个独一无二的地址，程序运行时，通过内存地址找到内存，取出内存中的数据，内存地址是16进制的数据，不方便记忆，怎么解决？
可以通过变量找到内存中的数据。

变量名

驼峰式命名法：第一个单词全小写，后续的单词首字母大写。
命名必须有意义，见名知意。
不能使用关键字，public static void等

数据类型：

数值：整型（整数），浮点型（小数）
非数值：字母，单词，汉字，字符。。。

Java中有8种基本数据类型

byte(基本单位) 1个字节：8位的二进制数（01010101）
int(整型) 4个字节：32位
short(短整型) 2个字节：16位
long(长整型) 8个字节：64位
float（单精度浮点型）4个字节：32位
double（双精度浮点型）8个字节：64位
char（字符类） 2个字节：16位
boolean（布尔，用来做逻辑判断） 1/8个字节，1位
true 1 / false 0
成立（真） 不成立（假）

4/10 = 2.5
3/10 = 3.3333333333333333333333333333333
无论如何存储，一定存在精度损失

创建变量的步骤：

1.声明变量 根据数据类型申请空间
int num;
2.赋值 将数据存储到内存空间
num = 1000;
=是一个赋值运算符，将等号右边的值赋给等号左边
3.使用 通过变量名取出数据
System.out.print(num);

关注我

链接

分类

最新文章

归档

标签

Java4
TypeScript2
css1
vue1
其它1

订阅更新

×