基础不牢，地动山摇
创建新项目
- 用IDEA重新创建一个新项目：左上角File找到CloseProject打开画面如下
New Project 点击后选择如图
继续下一步，填好名字及目录后点完成，接着会弹出Project Structure(项目结构)界面，暂时关闭，待会还会打开这个进行设置
此时Idea界面是个空的界面，是没法写代码，需要在File处New一个（Module...）模块，选中java(此处理解为在一个空的项目里创建一个java模块)，直接Next++;完成后，重新打开项目结构(Project Structure)[在File处可以找到打开]；点击Project,查看右侧Project SDK(未选java版本，处于报红状态)，修正后（1.8）修改Project language levet（8），与Java相互对应，然后应用关闭此窗口；现在java环境已配置，可以new java class写代码
注释
注释系统不会执行，给人看的 分为：
- 单行注释 在//后输入注释类容
- 多行注释 在/星 内多行输入注释 星/
- 文档注释 /星星 星/ 这个是有功能的，在里面加入参数会被识别[暂时不会用]
标识符//关键字
- 在Java中组成部分的名字。类名、变量名以及方法名都被称为标识符
- 关键字：
| abstract | asser | boolean（基本类型：比尔判断） | break（阻断穿透） | byte（基本数值整数类型） |
| case（）(和switch搭配) | catch | char（基本数值字符类型） | class{类} | const |
| continue{跳过某次循环} | default | do | double（基本数值浮点类型） | else（已知搭配if） |
| enum | extends | final(常量) | finally | float（基本数值浮点类型） |
| for(循环) | goto | if（判断） | implemenls | import |
| instanceof | int（基本数值整数类型） | interfac | long（基本数值整数类型） | native |
| new（新） | package（包） | private | protected | public（开头用） |
| relum | strictfp | short（基本数值整数类型） | static | super |
| switch（多选，搭配casee） | synchronized | this | throw | throws |
| transient | try | void（返回空） | volatile | while(循环) |
以后都会认识记住的，起名字不能用这些同名，这些标识符在Java中已被赋予意义
public class 类的名字{
public static void main(String[] args){
}//main，就是方法的名字
}
标识符注意点
- 所有标识符都应该以字母、美元符、下划线_来开始,例：
- 首字符之后可以是字母、美元符、下划线、或数字的任意字符组合，比如下面$helle可以改为$1hello
public class Demo01{
public static void main(String[] args){
String Ahello = "对字符串命名";
String hello = "对字符串命名";
String $hello = "对字符串命名";
String _hello = "对字符串命名";
//如果不按照此种命名将会报错
}
}
- 关键字不能作为方法名、变量名；
- 标识符大小写敏感A!=a;
数据类型
- 强类型语言：严格符合规定，例如前面标识符的规定
- 弱语言：没听明白
- Java数据类型分为：
- 基本类型：
- 数值类型
- 整数类型
- byte 1字节 范围：负2^(8-1) 到（2^8-1）-1
- short 2字节 范围：负2([8乘2-1])到（2[8*2-1]）-1
- int 4字节 范围：负2([8乘4-1])到（2[8*4-1]）-1
- long 8字节 范围：负2([8乘8-1])到（2[8*8-1]）-1
- // long比较特殊，一般定义long的数字后需要加L
- Long a = 10L;
- // long比较特殊，一般定义long的数字后需要加L
- 整数拓展：进制 二进制0b 十进制 八进制0 十六进制ox
- int i = 10; //10
- int i = 010; //八进制 8
- int i = 0x10; //十六进制 16
- 浮点类型//带有小数
- float 4字节
- float a= 10.1F //同long类似，也加字符首字母大写
- double 8字节
- float 4字节
- float 有限 离散 舍入误差 大约 接近但不等于
- 字符类型 char 2字节
- //此处为单引号，双引号是String，String是类不是关键字
- char a = 'A';
- 整数类型
- boolean类型 //字符的判断用equal
- true 和false都是占1字节
- 数值类型
- 引用类型
- 类
- 接口
- 数组
- 基本类型：
什么是字节
-
位(bit):计算机内部数据储存的最小单位，11001100是一个八位二进制。
-
字节(byte):是计算机数据处理的基本单位，习惯为B
-
1B = 8Bbit
-
字符：字母，数字，字和符号
数值类型强制转换
-
字符转为数字
char c1 = 'a'; System.out.println((int)(c1);
//所有字符都是数字 源自于一个编码表 Unicode 字符有对应的数字 //可以 char c2 = '\u0000'
//转义字符
// \t 空格
// \n 换行
类型转换
-
类型转换优先级：由低到高
byte,short,char,char-->int -->long-->float-->double//虽然long的字节比float大，但浮点数优先级高
int i = 128;
byte b = (byte)i; //强制转换 （类型）变量名
由于i的数大于byte最大范围，所以强制转换(byte)i，但会内存溢出
-
*转换
- 同理可得低优先级的可以直接转为高优先级而不受最大范围影响[低优先级的大部分值范围都在高优先级下]
- 谁让浮点优先级更高，但转换位整数时可能精度不准
拓展
JDK7特性数字可以用下划线分割 1000_0000
变量
要素包括变量名， 变量类型和作用域。
type varNamei [=value] [{,varNamei[=value]}];
//数据类型 变量 = 值； 可以使用逗号隔开来声明多个同类型变量。
可以这样写 ：int a= 1, b=2 , c=3 //但并不建议
一般还是 int a = 1;
int b = 2;
int c = 3;
变量作用域
- 类变量：写在类里面，和实例变量位置差不多，只是类变量需要加一个关键词 static
- 实例变量：方法的外面，类的里面，比如是在public class里面，public static void main外面，从属于对象，如果不进行初始化，比如 int age ,默认初始为0，布尔值为flase,除了基本值，其余都是null空
- 局部变量 在{}里的，并且必须对变量进行声明以及初始化
常量 final
初始化后不能改变的值
特殊的变量，值被设定后，在程序运行过程中不允许被改变。
final 常量名 = 值；
final double PI= 3.14 //常量名一般为大写字符。并且final做为一种修饰符，修饰符之间不用区分前后
变量的命名规范
- 所有的变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：mothSalary
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线： MAX_VALUE
- 类名：首字母大写和驼峰原则
- 方法名：首字母小写和驼峰原则
运算符:
operator
- 算数运算符：+,-.*,/,%(余)，++（循环自己加1），--（自己循环减1）
- 赋值运算符= //a=b，b的值赋个s
- 关系运算符：>,<,>=,<=,==,!=(不等于)
- 逻辑运算符：&&与，||或，！非
- 位运算符：&(位，二进制的与运算),|(同前),^(取反，相同取0不相同取1),~,>>,<<,>>(了解！！！)
- a= 0011 1100 b=0000 11101 //a&b ~b就是b=11111 00010 //
- << 左移 >>右移 用机器语言计算2*8 2<<2 相当于二进制 0000 0010向左移动3位 00001000
- 位运算效率极高
- 条件运算符 ? : //x ? y : z //如果x为true 则结果为y，否则结果为z
- 扩展赋值运算符：+=,-=,*=,/= //a+=就是 a=a+1
- 字符串连接符+ /如果System.out.println(" "+1+2)则输出 12起连接作用，如果(1+2+" ")则为3
//基数相加，由Long结果Long,没有就是int
//幂运算： double p = Math.pow(3,4) //3^4 //意思是pow是工具类Math的一种方法
包机制
包的本质就是文件夹
- 一般利用公司域名倒置作为包名
- 如果需要使用某个包的成员，需要在Java程序中明确导入该包。使用”import"语句可以完成此功能
- import package1[.package2....] (classname}*); //就是文件夹.里面的文夹.里面的文件，也可以最后的文件用星号代替，表示导入最后那个包的全部
JavaDoc
-
javadoc命令是用来生成自己API文档的
-
参数信息
- @author 作者名
- @version版本号
- @since指明需要最早使用的jdk版本
- @parm参数名
- @return 返回值情况
- @throws 异常抛出情况
-
网上搜JDK帮助文档，查看8,现在已下载到本地
package /** *@author 作者名 *@version版本号 *@since指明需要最早使用的jdk版本 */ public class Doc{ String name; /** * * @param name * @return */ public String test(String name){ return name; } }//加到类上面，是类的注释。加到方法上面，是方法的注释。
Java流程控制
用户交互Scanner
- 实现程序和人的交互，用到工具包是 java.util.Scanner是Java5的一个新特征，通过Scanner类来获取用户输入
- 基本语法是 Scanner s = new Scanner(System.in);
- 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNext
Scanner scanner = new Scanner(System.in)//先new一个Scanner对象接收用户的输入System.in，并且封装成了一个scanner对象
if(scanner.hasNext()){ //判断scanner有没有输入
String str = scanner.next(); //如果有输入，那么输入的东西用next接收并赋值给str
//可以多行不同类型赋值，键盘输入时就可以一次输入不同数据
System.out.println(str);
}//一般是不用添加if
scanner,close()； //用完小写的scanner要关掉，如果不关掉，IO类就会一直占用资源。得查下原理
next与nextLine区别：像Hello World next会将有效字符串后面的空白作为分隔符或结束符去掉。输出Hello
//在后面做的一个计算器输入1+2这三个字符是要分别打空格才识别出是三个，Line是回车前的所有字符
顺序结构 结构struct
- 就是一句一句向下执行，语句与语句，框与框
选择结构
-
if单选 if(判断boolean){为真执行}
-
if双选 if(判断boolean){执行}else{}
-
if多选 if(判断boolean){执行}else if{} else{}//中间else if可以多个else if
-
if嵌套结构 if(判断boolean){if(判断boolean){为真执行}}
-
switch多选择结构
实现方式是switch case switch(定义对象){case对象值:执行；case对象值:执行；case对象值:执行；case对象值:执行；}//定义对象的值相对应则执行，但case具有穿透性，所以执行处添加break; 注意case后的符号是冒号
- Java7后switch支持支付串
循环结构
之前一直纠结的为啥循环时，只能用一次system.in就不让第二次输入了的原因是没有将has.Next()放入循环内，想通过下面这个得到启示做一个可以持续加减乘除的计算器。
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++;
sum = x +sum;
System.out.print("和"+sum);
System.out.print(" 第"+m+"个");
System.out.println(" 平均数"+sum/m);
}
scanner.close();
}
做了一个计算器
public static void main(String[] args) {
System.out.println("计算器\n请输入数值空格运算符空格数值回车：");
Scanner scanner = new Scanner(System.in);
double sum = scanner.nextDouble();//初始sum做为循环内sum的初始量，只有首次手动输入，所以不写在while，后面的sum由sum和x的运算结果赋值完成循环持续计算
while(scanner.hasNext()){
String s = scanner.next();
double x = scanner.nextDouble();
System.out.print("值为:");
switch (s){
case "+":
sum = sum + x;
System.out.print(sum);
break;
case "-":
sum = sum - x;
System.out.print(sum);
break;
case "*":
sum = sum * x;
System.out.print(sum);
break;
case "/":
sum = sum / x;
System.out.print(sum);
break;
case "c":
sum = 0;
System.out.print(sum);
break;
}
}
scanner.close();
}
while 循环
while(判断){循环类容}
do...while 循环
for 循环
for( ; ; i++){}
增强For循环
public static void main(String[] args){
int[] numbers = {10,20,30,40,50};//定义数组
//遍历数组的元素
for(int x:numbers){ //意思是将numbers[]的数组每一项依次都赋值给了x,循环x输出number值
System.out.println(x);
}
}
break&continue
break，用于强行退出循环
比如a=0,循环a++,若果输出值为5时用break，那么从这往后都不执行了
continue,跳过某次循环
和break区别是只是逃过值为5的s，后面继续执行
关于goto关键字
特定条件下的黄色闪电，不建议使用
public static void main(String[] args){
//打印101-150所有的质数
int count = 0;
outer:for(int i=101;i<150;i++){
for (int j = 2; j<i/2;j++){
if(i%j == 0){
continue outer;
}
}
System.out.print(i+" ");
}
}
练习
Java方法详解
何谓方法
- System.out.println(),//System是一个系统的类，out是System下的一个输出对象，（）就是一个方法
- 方法包含于类和对象中
- 设计方法的原则，一个方法只完成一个功能，利于我们后期拓展
- 方法的命名：小写驼峰原则
创建一个加法
public static void main(String[] args){
int add = add(1,2);
}
//public int add(int a.int b){ //加法一般有两个数，在方法名中设置两个数：inta intb
return a+b;
}//这种情况下是调用不了，需要加个static(成为类变量)
public static int add(int a.int b){ //加法一般有两个数，在方法名中设置两个数：inta intb
return a+b;
}
方法的定义
-
Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
-
方法包含一个方法头和一个方法体。
-
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
-
返回值类型：如果输出一个话，社么都不返回，则用用void
-
比如 public static double[] name(double x){方法体return 结果;}假如定义结果为sum,那return sum;
public static void double name(){方法体System.out.println()}
public static int max(int num1.int num2){ //此处用逗号，而不是分号； int result = 0; if(num1==num2){ System.out.println("num1==num2"); return 0;//终止方法 } if (num1<num2){ result = num1; }else { result = num2; } return result; } -
-
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
-
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实际惨或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。用时实参赋值给形参
-
方法体：方法体包括具体的语句，定义该方法的功能。
-
方法调用
- 调用方法：对象名.方法名（实例参数）
- 两种调用，返回值，当一个值，返回void，调用一定是一条语句。
Java是值传递：社么是值传递，什么是引用传递
方法的重载
-
意思是写了两个或两个以上的同名不同类型的方法
public static double name(souble){}//类型指的是括号里的,外面指返回值类 public static int name(int){} -
方法重载的规则：
- 方法名称必须相同。
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载、
-
实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
命令行的传参
- 有时候你希望运行一个程序时候再给它消息。这要靠传递命令行参数给main()函数实现。
public static void main(String[] args){
for(int i = 0; i< args.length; i++){
System.out.println("args["+i+"]"+args[i]);
}
}
假如上面的程序是Name.java在某个文件夹：C\W\src\com\1里
-
打开doc窗口，输入C\W\src\com\1>javac Name.java //此处是编译java文件，同目录会生成一个同名.class
-
退到src路径>java com.1,Name //执行此程序
-
由于啥也没有，执行也是空的，重新执行>java com.1,Name this is dddd 回车
输出：args[0]: this
args[1]: is
args[2]:dddd
args[3]:回车
可变参数
-
在方法声明中，在指定参数类型后加一个省略号.(...).
-
一个方法只能指定一个可变参数，它必须是方法最后一个参数。任何普通的参数必须在它之前声明。
public static void main(String[] args) { Demo10 demo10 = new Demo10(); demo10.test(11,22,5);//这个的长度得和i相同 } public void test(int...i){ System.out.println(i[0]); System.out.println(i[1]); System.out.println(i[2]); }
public static void printlnMax( double...numbers){
if(numbers.length ==0){ //如果可变参数长度为0则输出
System.out.println("No argument passed");
return; //然后返回
}
double result = numbers[0]; //定义了个返回值 result ,拿到下面排序比较赋值
//排序
for (int i = 1; i < numbers.length; i++){ /
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("The max value is "+result);
}
递归
- A方法调用B方法，我们很容易理解！
- 递归就是：A方法调用A方法！就是自己调用自己
- 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
- 递归结构包括两个部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体：什么时候需要调用自身方法。
//算阶层举例,尽量不用递归法，它只是提供一种思路
public static int f(int n){ //定义一个int返回值方法，
if (n==1){
return 1; //因为阶层最后都是1，所以此处用n==1做为递归头阻断循环
}else {
return n*f(n-1); //递归体，自己调用自己，f(n-1)就是自己
}
}
//像这个用while一样可以达到目的，并且计算范围还大些
public static double ab(double a){
double b = 1;
while (a>1){
b = b*a--;
}
return b;
}
数组 array
数组定义
相同类型数据的有序集合，每一个数据称为一个数组元素，一个数组里的个数和被称作长度，每个数组元素都有下标，下标最高有长度减一个
创建
int[] name;
name = new int[10];//长度10【name.length】，可以放10个，下标0-9对应第1-10的数name[0-9]=={1-10},下标对应的值没有默认为0
Java内存分析
Java内存
-
声明数组
int[] array = null; //此时 array放在栈
-
创建数组
array = new int[10]; //此时array在推里面开辟了一个被分为十份的空间，这十份的小空间待赋值，目前是默认值
- 堆 //像平时new Scanner的对象就是放在堆里
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
- 栈 //真正放具体的值
- 存放基本变量类型（会包含这个基本类型的具体数值}
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量
三种初始化
-
静态初始化
int[] a = {1,2,3,}; //创建加赋值
Man[] mans = {new Man(1,1),new Man(2,2)};
-
动态初始化
int[] a = new int[2];
a[0]=1;
a[1]=2;
- 数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被安装实例变量同样的方式被隐式初始化。
数组的四个基本特点
-
其长度是确定的。数组一旦被创建，它的大小就是不可能改变的。
-
其元素必须是相同类型，不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
-
数组变量属引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。
- 数组就是对象，Java中对象是指堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。
数组边界
- 其长度是确定的。数组一旦被创建，它的大小就是不可能改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。
- 数组就是对象，Java中对象是指堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。
数组边界
- 下标的合法区间：【0，length-1】,如果越界就会报错；
public static void main(String[] args){
int[] a= new int[2];
System.out.println(a[2]);//报错
}
- java.lang.ArrayIndexOutOfBoundsException: 数组下标越界异常！
- 小结：
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是有对象。数组元素相当与对象的成员变量
- 数组长度确定的，不可变的。如果越界，则报ArrayIndexOutOfBounds
数组使用
-
For-Each循环
- 普通Forx循环
public static void main(String[] args){ int[] arrays = {1,2,3,4,5}; //静态 //打印全部的数组元素,求和 int sum = 0; for(int i = 0; i<arrays.length;i++){ System.out.print(arrays[i]); sum = sum + arrays[i]; } System.out.println(); System.out.println("==============================="); System.out.println(sum); //找最大值 int max = 0;//此处等于零不好，应改为 int max = arrays[0],如果arrays[i]全是负数，那就成零是最大的 for(int i = 0; i<arrays.length;i++){ if(max<arrays[i]){ max = arrays[i]; } } System.out.println(max); }- 增强for循环 //arrays.for按住alt+enter自动填充成 for(int array:arrays){}循环
public static void main(String[] args){ int[] arrays = {1,2,3,4,5}; //JDK1.5，没有下标，适合打印数组 for(int array : arrays){ //冒号后面代表数组，前面代表数组的美一个元素 System.out.println(array);//注意输出的是元素不是数组 } } -
数组作方法入参
写一个打印数组元素的方法
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
引用入参在main打印，printArray(arrays)?//此处arrays需要定义new一个赋值
- 数组作返回值
写一个反转数组并返回
public static void main(String[] args){
int[] arrays = {1,2,3,4,5};
//printArray(reverse());
int[] reverse = reverse(arrays);//reverse(arrays)返给reverse的结果已经是被反转的结果，已经把数组当返回值
System.out.println(reverse(arrays));//输出显示是个一个地址，这地址就是被反转的数组地址,存的54321
printArray(reverse(arrays));//printArray括号里得是个数组/
}
public static int[] reverse(int[] arrays){//对于返回值 在方法名前的类型有的加[]是代表返回的数组类型，
int[] result = new int[arrays.length]; //new int(数字)代表result开辟了一个被分为五份的int类型空间
for(int i = 0 ,j=result.length-1;i<arrays.length;i++,j--){
result[j]=arrays[i];/*result是在方法这创建的，arrays是在main创建的，前则是动态数组，后者是静态数组
现在这一步的意思就是将result这个动态数组进行赋值，下标从4到0挨个将arrays的值从下标0-4挨个赋值。
从0-4五轮结束赋值完毕。结束后result[4]=={0,0,0,0,0}以赋值为{5，4，3，2，1}已成为array的反转数组，
*/
} //从这结束后,就可以将result返回为这个方法的输出了，也可在这用个方法或自写一个方法将result打印出来
return result;
}
//打印数组
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
上一篇： 数据分析师如何点技能点？
推荐阅读
-
像首席技术官一样思考：如何高效管理 30 人的研发团队？-管理越多越轻松。好的研发团队，应该是上拨下用，即下级对上级的向上管理；而不是反过来，总是向下管理，甚至是 CTO 做经理的事，经理做工程师的事，工程师最终会被当成实习生。如果是这样，就会越管越累，不仅团队无法成长，而且团队整天很忙还效率低下，问题一大堆。 有这样一个小故事：一位高级经理下班后帮忙倒垃圾，结果被老板训斥了一顿。这就好比首席技术官做了实习生自己该做的事。事情本身没有对错之分，只是从不同的角度有不同的理解。 古人云："用人不疑，疑人不用"。在面对自己的研发团队时，应该相信他们能做好，授权一线开发人员充分发挥专业特长，不要限制他们的工作。但在相信他们的同时，也要进行二次确认，始终秉持 "我相信，但我要确认 "的原则和严谨的精神。因为每个人都会犯错和疏忽，通过发挥团队的智慧，团队犯错的机会就会大大减少。比如回归测试、代码审查、开发演示、变更审批等等。 如前所述，每个人都难免会犯错。但作为管理者，你所设计和商定的流程不能出错。管理者的每一个决定和沟通都应该经过深思熟虑。就像红绿灯的交通设计，某辆车不小心闯红灯可能会扣分，但红绿灯的设计一定要正确、人性化、统一。再比如，开发人员可能会因为疏忽大意写出 bug，但研发流程的设计和上线流程的发布不能有任何差错。因此，流程体系的设计，一方面要结合当前团队规模、业务特点和需要重点解决的问题来设计，另一方面也要在人员防错、效率提升、发挥团队集体智慧等维度进行综合考量。应该站在更高更抽象的角度去思考，不断思考一个倍受欢迎的园区应该如何设计，思考一个灵动、经典、永恒的建筑应该遵循怎样的模式，思考一个成功、优秀、卓越的研发团队应该需要怎样的流程和制度。 最后，反馈很重要。向上汇报很重要，向下反馈也很重要。能够保持顺畅的双向反馈和闭环管理，对研发团队的协作和沟通有着非常明显的积极作用。在向上汇报方面，要培养团队在正式汇报、会议汇报、私下沟通、书面总结、非正式场合等方面的沟通能力，提醒下属报喜也要报忧。凡事先记录，再跟进，最后反馈。反馈很重要，主动汇报更难得。 另一方面，同时也不要忽视向下反馈。好的爱，是双向的。团队也是如此，没有严格的上下级之分，只是分工和角色不同而已。作为管理者，不必总保持一种 "神秘感"，让人 "捉摸不透 "才是牛。当团队做得好或有人做得好时，要记得在公开或私下场合给予肯定和赞许。业务有增长、业绩有提升时，别忘了给团队一些鼓励，或者安排一次下午茶或聚餐。在例会或正式会议上，也可以同步向大家传达一些重要信息和高层指示。"欲速则不达，欲远则同行"。 当向上汇报、向下反馈的沟通闭环形成后，同时结合前面研发过程的管理闭环，双管齐下，就能形成良性循环。如此反复，持之以恒，优秀卓越的研发团队，必将呈现。 能力、产出和效率 接下来，继续重复关于能力、产出和效率的话题。 站在不同的角色，以及一个企业经营、生存和发展所需要的基础上，我把研发生产力分为三个层次，分别是：一线员工关心的研发能力、管理层关心的软件产出和操作人员关心的企业生产效率。简单概括就是：既要把工作做好，又要能出成果，还要能帮企业赚钱。
-
非法篡改数据会破坏信息安全的哪些属性 - 机密性（保密性）是指不向未经授权的用户、实体或流程披露网络信息。也就是说，信息只能由授权用户使用。保密性是在可靠性和可用性基础上确保网络信息安全的重要手段。 (推荐学习：网络前端视频教程） 网络信息安全中的保密性是指根据给定的要求，信息不泄露给未经授权的个人、实体或进程，或提供给他们使用的特性，即杜绝有用信息泄露给未经授权的个人或实体，强调有用信息只被授权对象使用的特性。 常用的保密技术
-
基础不牢，地动山摇
-
基础不牢，地动山摇
-
面试官让我意识到[基础不牢]的绝望！
-
基础不牢，地动山摇。让我们来学习 Java。
-
基础不牢，地动山摇
-
[如果基础不牢固，C 语言中的静态关键字就会动摇地基✊]。
-
基础不牢，地动山摇。20 分钟取阵列。
-
Day14 基金会基础不牢固 - Java 基金会