java学习之旅（day.06）
switch多选择结构
多选择结构还有一个实现方式就是switch case
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
switch(expression){
case value:
//语句
break；
case value;
//语句
break；//可以有任意数量的case语句
default：
//语句
}
switch语句中的变量类型可以是：
- byte, short , int或char
- javaSE 7开始支持字符串类型了，同时，case标签必须为字符串常量或字面量
package com.zhang.structure;
public class SwitchDemo01 {
public static void main(String[] args) {
char grade ='C';
//switch匹配一个具体的值
switch (grade){
case'A':
System.out.println("优秀");
break;
case'B':
System.out.println("良好");
break;
case'C':
System.out.println("及格");
break;
default:
System.out.println("未知");
}
}
}
====================================================
package com.zhang.structure;
public class SwitchDemo02 {
public static void main(String[] args) {
String name ="张三";
//JDK7的新特性，表达式结果可以是字符串
//字符串的本质还是数字
//反编译，java文件编译后生成class文件，class文件是字节码文件，人看不懂，
//需要转为人看懂的文件，即反编译。工具用：IDEA
//方法：打开Project Structure
// 找到项目输出路径，可以据此找到class文件在哪，然后将class文件放到
//对应的java文件中，就可以在IDEA中打开
switch (name){
case"张三":
System.out.println("张三");
break;
case"李四":
System.out.println("李四");
break;
default:
System.out.println("不知道");
}
}
}
循环结构
- while循环
- do...while循环
- for循环
- 在java5中引入了一种主要用于数组的增强型for循环
while循环
while循环是最基本的循环，结构为：
while（布尔表达式）{
//循环内容
}
package com.zhang.structure;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1-100
int i=0;
while(i<100){
i++;
System.out.println(i);
}
}
}
====================================================
package com.zhang.structure;
public class WhileDemo02 {
public static void main(String[] args) {
//计算1+2+3+...100的和
int i=0;
int sum=0;
while(i<100){
i++;
sum=sum+i;
//++i;
}
System.out.println(sum);
}
}
- 只要布尔表达式为true，循环会一直执行下去，但大多数情况会让循环停下来，我们需要一个让表达式失效的方式来结束循环
- 少部分情况需要循环一直执行，比如服务器的请求响应监听等
do while 循环
do while语句表达
do{
//代码语句
}while（布尔表达式）；
对于while循环而言，如不满足条件，则不能进入循环
有时即便不满足条件，我们也至少需要执行一次，此时，就要用到do...while循环，do...while与while循环相似，区别在与do...while至少执行一次
while循环先判断后执行，do...while先执行，后判断。
package com.zhang.structure; public class DoWhile01 {
public static void main(String[] args) {
//计算1+2+3+...100
int i=1;
int sum=0;
do{
sum=sum+i;
i++;
}while(i<=100);
System.out.println(sum);
}
}For循环
所有的循环后可以用while或do while表示，但java中的For循环会使一些循环结构变得更简单
for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构
for循环的运行次数在执行前就是确定的。
语法格式：
for(初始化；布尔表达式，迭代更新){
//代码语句
}
快速打出for循环：100.for
package com.zhang.structure;
public class ForDemo01 {
public static void main(String[] args) {
//初始化//条件判断//迭代更新
//for(int i=0;i<=100;i++){
//System.out.println(i);
//最先执行初始化步骤，可声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
//然后检查布尔表达式的值，若为true，执行循环，若为false，循环终止，执行循环体后的内容
//再次检查布尔表达式，执行循环
//for（；；）死循环
//==========================================================
//计算0-100间所有基数和偶数的和
// (我写的）
int sum1=0;
int sum2=0;
for (int i = 0,s=1; i<100; i+=2,s+=2) {
sum1=i+sum1;
sum2=s+sum2;
System.out.println(i);
System.out.println(s);
}
System.out.println(sum1);
System.out.println(sum2);
//老师讲的
//int oddsum=0;
//int evensum=0;
//for (int i = 0; i < 100; i++) {
// if(i%2!=0){
// oddsum+=i;
// }else{
// evensum+=i;
// }
//}
//System.out.println("奇数的和："+oddsum);
//System.out.println("偶数的和："+evensum);
}
}
==================================================
package com.zhang.structure;
public class ForDemo02 {
public static void main(String[] args) {
//用while或for语句输出1-1000间能被5整除的数，且每行输出三个
for (int i = 0; i <=100; i++) {
if (i%5==0){
System.out.print(i+"\t");//空格
}
if (i%(3*5)==0){//每行3个
System.out.println();//换行，也可用System.out.print(“\n”);
}
//print与println的区别：print输出不会换行，println输出后会换行
}
}
}
====================================================
package com.zhang.structure;
public class ForDemo03 {
public static void main(String[] args) {
//打印九九乘法表
//1.打印第一列
//2.把固定的1再用一个循环包起来，让1也成为变量
//3.九行九列中有重复的，要去掉重复的
//4.调整样式
for (int j = 1; j <=9; j++) {
for (int i = 1; i <=j; i++) {
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
增强for循环
数组的时候使用
增强for循环是一种主要用于数组或集合的
语法格式：
for（声明语句：表达式）
{
//代码句子
}
package com.zhang.structure;
public class ForDemo05 {
public static void main(String[] args) {
//增强for循环
int[] numbers={10,20,30,40,50};//定义了一个数组
for (int x:numbers){//遍历数组的元素：把数组numbers中的每一个元素遍历出来赋值给x
System.out.println(x);
}
System.out.println("====================");
//一般的for循环
for (int i = 0; i < 5; i++) {
System.out.println(numbers[i]);
}
}
}
break 与continue
break:在任何循环语句的主体部分，均可用break控制循环的流程提前终止循环，break强行退出循环，不执行循环中剩余的语句。继续执行下面的语句
continue：用在循环语句中，提前结束本次循环，即跳过循环中尚未执行的语句，接着执行下一次是否执行循环的判定。循环结束后，继续执行下面的语句
package com.zhang.structure;
public class TestDemo01 {
public static void main(String[] args) {
//打印三角形5行
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();
}
}
}
方法
System.out.println（）
类 对象 方法
调用系统类里的标准输出对象out中的方法叫做println方法
- java方法是语句的集合，他们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他方法被引用
- 设计方法的原则：一个方法只完成1个功能，这样有利于后期的扩展
package com.zhang.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
//int sum=add(1,2);
// System.out.println(sum);
test();
}
//加法
public static int add(int a,int b){
//修饰符 返回值类型
return a+b;
}
public static void test(){
for (int i = 0; i <=100; i++) {
if (i%5==0){
System.out.print(i+"\t");//空格
}
if (i%(3*5)==0){//每行3个
System.out.println();//换行，也可用System.out.print(“\n”);
}
//print与println的区别：print输出不会换行，println输出后会换行
}
}
}
方法的定义
java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值；
}
方法包含一个方法头和方法体，下面是一个方法的所有部分：
修饰符：是可选的（可以不写），告诉编译器如何调用该方法，定义该方法的访问类型
返回值类型：方法可能返回值，有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType（返回值类型）是关键字void
方法名：方法的实际名称，随便取，但要遵守规范：首字母小写驼峰原则
参数类型：实参和形参
实参：参数像个占位符，当方法被调用时，传递值给参数，这个值称为实参或变量（在方法被调用时用于接收外界输入的数据）
形参：调用方法时实际传递给方法的数据
参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数
package com.zhang.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
//实际参数：实际调用传递给他的参数
int sum=add(1,2);
System.out.println(sum);
//test();
}
//加法
//形式参数：用来定义作用的
public static int add(int a,int b){
//修饰符 返回值类型
return a+b;
}
public static void test(){
for (int i = 0; i <=100; i++) {
if (i%5==0){
System.out.print(i+"\t");//空格
}
if (i%(3*5)==0){//每行3个
System.out.println();//换行，也可用System.out.print(“\n”);
}
//print与println的区别：print输出不会换行，println输出后会换行
}
}
}
方法体：方法包含具体的语句，定义该方法的功能
返回值：如果方法存在返回值，一定要把返回值通过return这个关键词返回出去，如果是void就不用返回了
方法调用
- 调用方法：对象名.方法名（实参列表）
- java支持两种调用方法的方式，根据方法是否返回值来选择
- 当方法返回一个值得时候，方法调用通常被当做一个值。如：int larger =max（30，40）；
- 如果方法返回值是void，方法调用一定是一条语句
如：System.out.println("hello,zhang“）；
package com.zhang.method;
public class Demo02 {
public static void main(String[] args) {
int max=max(10,20);
System.out.println(max);
}
//比大小
public static int max(int num1,int num2){//形式参数
int result=0;//这里result的初始化值写多少都行，后面会被覆盖
if (num1==num2) {
System.out.println("num1=num2");
return 0;//return除了返回结果的意思，还有终止方法的作用
}
if(num1>num2){
//这里写return会报错，一般return写到最外边，为了将num1返回出去，要定义一个变量result
result=num1;
}else{
result=num2;
}
return result;
}
}
值传递（java）和引用传递
方法的重载
重载就是在一个类中，有相同的函数名称，但形参不同的函数
方法的重载原则：
- 方法名称必须相同
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
方法名称相同时，编译器会根据调用方法的参数个数，参数类型等逐个去匹配，以选择对应的方法，如果匹配失败，则编译器报错
命令行传参（了解）
有时候希望运行一个程序的时候再传递给它消息，这要靠传递命令行参数给main（）函数实现
可变参数
1.5开始，java开始支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数的类型后加一个省略号(...).
一个方法只能指定一个可变参数，且必须是方法的最后一个参数。任何普通参数必须在它之前声明
package com.zhang.method;
public class Demo05 {
public static void main(String[] args) {
//调用可变参数的方法
printMax(34,3,3,2,56.5);//给一组数
printMax(new double[]{1,2,3});//传给一个数组
}
public static voizd printMax(double...numbers){//传递多个double类型的参数
if (numbers.length==0){
System.out.println("no argument passed");
return;
}
double result =numbers[0];
//排序
for (int i = 1; i < numbers.length; i++) {
if (numbers[i]>result){
result=numbers[i];
}
}
System.out.println("Max value is:"+result);
}
}
递归
递归就是A方法调用A方法，即自己调用自己
利用递归可以用简单地程序来解决一些复杂的问题，通常把复杂的大型问题层层转化为一个与原问题相似的规模较小的问题求解
递归结构包括两个部分：
- 递归头：什么时候不调用自身的方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身的方法
基数比较大的时候能不用递归就不用递归
package com.zhang.method;
public class Demo07 {
public static void main(String[] args) {
System.out.println(f(5));//此处基数过大的话，能不用递归就不用递归
}
public static int f(int n){
if (n==1){
return 1;
}else{
return n*f(n-1);
}
}
}
数组
相同类型的数的有序 集合
数组声明创建
首先必须声明数组变量，才能在程序中使用数组，声明数组变量的语法如下：
dataType[]arrayRefvar；//首选的方法
或
dataType arrayRefvar[]；//效果相同，但不是首选的方法
java使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar=new dataType[arraySize];
数组的元素通过索引来访问，数组索引从0开始
获取数组的长度 arrays.length
package com.zhang.array;
public class ArrayDEMO01 {
public static void main(String[] args) {
//变量类型 变量名=变量值；
//定义一个数组有以下两种方法：
int[] nums;//首选
//int类型的数组
int nums2[];//在c或c++中使用的多，上面两种方法仅仅声明了一个数组，并没有分配空间，下面一行分配了空间
nums=new int[10];//这里面可以存放10个int类型的数字,创建了一个数组
//也可以将上面两句话合成一句话：声明并创建：int[] nums =new int[10]
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;//给数组元素赋值
System.out.println(nums[0]);
int sum=0;
//计算所有元素的和
for (int i = 0; i < nums.length; i++) {
sum=sum+nums[i];
}
System.out.println("总和为："+sum);
}
}
数组的三种初始化
- 静态初始化
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;
- 数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化
package com.zhang.array;
public class ArrayDemo02 {
public static void main(String[] args) {
//静态初始化:创建加赋值
int[] a={1,2,3,4,5,6,7,8};
System.out.println(a[0]);
//动态初始化,包含默认初始化
int[] b=new int[10];
b[0]=1;
}
}
数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
- 其元素必须是相同类型，不允许出现混合类型
- 数组中的元素可以是任意数据类型，包括基本类型和引用类型
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中的对象是在堆中，因此，数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组的边界
- 下标的合法区间：[0,length-1],如果越界就会报错
比如：数组的长度是10，则下标的有效区间是0-9
数组下标越界异常：ArrayIndexOutOfBoundsException
数组的使用
- For-Each循环
- 数组做方法用参
- 数组做返回值
- 普通for循环
package com.zhang.array;
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
// for (int array : arrays) {//增强型for循环
//数组里面的每一个元素 数组
// System.out.println(array);
// }
//printArray(arrays);
int[] reverse=reverse (arrays);
System.out.println(reverse);
printArray(reverse);
}
//打印数组元素(数组做方法用参）
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(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 a[] []=new int[2] [5];//2行5列的数组
原来一维中存个数，现在二维存的是数组
多维：数组里面嵌数组
package com.zhang.array;
public class ArrayDemo04 {
public static void main(String[] args) {
//4行2列
/*
1,2 array[0]
2,3 array[1]
3,4 array[2]
4,5 array[3]
*/
int[][] array={{1,2},{2,3},{3,4},{4,5}};
System.out.println(array[0][0]);//1
System.out.println(array[2][1]);//4
printArray(array[0]);//1 2
System.out.println("============");
//输出数组的长度
System.out.println(array.length);//4
System.out.println(array[0].length);//2
System.out.println(array[1].length);//2
//输出二维数组中的元素
System.out.println("=======");
for (int i = 0; i < array.length; i++) {
for (int j=0; j<array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i <arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
Arrays类
数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而科一对数据对象进行一些基本的操作
可以查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而不用使用对象来调用，你想用也行
常用功能：
- 给数组赋值：通过fill方法
- 对数组进行排序：通过sort方法（升序）
- 比较数组：通过equals方法比较数组中元素值是否相等
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作
package com.zhang.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a={1,2,3,4,9900,5486,5,98,3};
System.out.println(a);//[I@14ae5a5
//打印数组元素
System.out.println(Arrays.toString(a));
printArray(a);
//对数组中的元素进行排序
Arrays.sort(a); //升序排序
System.out.println(Arrays.toString(a));
//给数组赋值，（填充）
Arrays.fill(a,0);//把数组a的元素填充为0
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,4 ,0);//把数组a的下标为2-4的元素填充为0
System.out.println(Arrays.toString(a));
}
//自己写一个方法打印出数组
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if (i==0){
System.out.print("[");
}
if (i==8){//或写成i==a.length-1
System.out.println(a[i]+"]");
}else {
System.out.print(a[i] + ", ");
}
}
}
}
冒泡排序
package com.zhang.array;
import java.util.Arrays;
public class ArrayDemo07 {
//冒泡排序:时间复杂度为O（n^2）
//1.比较数组中两个相邻的元素，如果第一个>第二个，则交换位置
//2.每次比较都会产生一个最大或最小的数字
//3.下一轮就可以少一次排序
//一次循环，直至结束
public static void main(String[] args) {
int[] a={1,8,6,7,9,89,56,45,198,237};
int[] sort = sort(a);//调用完自己写的排序方法后返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
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-i; j++) {//优化：假设进来这些循环时已经有序了就不需要再比较了
if (array[j+1]>array[j]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag=true;//优化，排完续的flag置为true，若都没有交换，flag=false
}
}
if (flag==false) {//优化，说明这一轮没有进行比较，说明结束了
break;
}
}
return array;
}
}
稀疏数组
压缩，数据量变小
- 当一个数组中大部分为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组
- 稀疏数组的处理方式：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而减小规模
- 如下：左为原始数组。右为稀疏数组
6 7 8 6行7列8个有效的数字
0 3 22 第0行第3列的值是22
package com.zhang.array;
public class ArrayDemo08 {
public static void main(String[] args) {
//1.创建一个二维数组11*11 0：没有棋子 1：黑棋 2：白棋
int[][] array1=new int[11][11]; //一个11*11的二维数组，但此时没有赋值，都是0
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();
}
//转换为稀疏数组来保存
//获取有效值的个数
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;
//遍历二维数组，将非0的值存放在稀疏数组中
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");
/*
11 11 2
1 2 2
2 3 3
*/
}
//还原稀疏数组
System.out.println("还原稀疏数组：" );
//1.读取稀疏数组的值
int[][] array3=new int[array2[0][0]][array2[0][1]]; //数组大小
//2.给其中的元素还原值
for (int i = 1; i <array2.length; i++) {//这里i从1开始，不是o，第一行是头部信息
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
//3.打印输出
System.out.println("输出还原后的数组：");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
java学习之旅（day.06）的更多相关文章
- Java学习之旅开篇：运行机制及环境搭建
在写这篇博客之前,我想对自己进行简单概括:我从事软件开发工作已经三年多了,并且一直在从事.NET相关项目的开发.为什么突然间想学习Java呢?有以下几个原因: 1. 开发程序三年多来,已经对.NET相 ...
- Java学习之旅基础知识篇：面向对象之封装、继承及多态
Java是一种面向对象设计的高级语言,支持继承.封装和多态三大基本特征,首先我们从面向对象两大概念:类和对象(也称为实例)谈起.来看看最基本的类定义语法: /*命名规则: *类名(首字母大写,多个单词 ...
- 第一篇，java学习之旅
在java的这座殿堂中,我才刚刚推开了大门,就像是在岔路口找到了一条,走向前进java大门的路. 下面是一些java算法的问题 第一题: package project.model; import j ...
- Java学习之旅（一）：探索extends
鄙人为兴趣爱好,0基础入门学习Java,有些心得想法,记录于此,与君分享. 然毕竟新手,学识尚浅,错误之处,希望多多指正批评,也是对我最大的帮助! 前言:本篇文章,主要讨论在子类继承父类之后,一些继承 ...
- Java学习之旅基础知识篇：数组及引用类型内存分配
在上一篇中,我们已经了解了数组,它是一种引用类型,本篇将详细介绍数组的内存分配等知识点.数组用来存储同一种数据类型的数据,一旦初始化完成,即所占的空间就已固定下来,即使某个元素被清空,但其所在空间仍然 ...
- Java学习之旅基础知识篇：数据类型及流程控制
经过开篇对Java运行机制及相关环境搭建,本篇主要讨论Java程序开发的基础知识点,我简单的梳理一下.在讲解数据类型之前,我顺便提及一下Java注释:单行注释.多行注释以及文档注释,这里重点强调文档注 ...
- 我的java学习之旅--一些基础
(因为我粗略学过C,C++,Python,了解过他们的一些语法,所以为了使得java的入门更为顺畅,便会忽略一些和C语法相类似的地方,着重点明一些java自己的特色之处.也减轻一下自己写文字的负担.) ...
- Java学习之旅（二）：生病的狗1(逻辑推导)
前言:本篇文章属于个人笔记,例化了一些代码,不知是否合理,请指教. 中午看到一位同学的面试题,觉得很烧脑,烧脑不能一个人烧,要大家一起烧. 村子中有50个人,每人有一条狗.在这50条狗中有病狗(这种病 ...
- java学习之旅
jar文件其实就是一个压缩包,里面包含很多class文件(一个class文件是一个类的字节码).方便在网络上传输.可以规定版本号,更容易进行版本控制. var只能在方法内使用,不能用于定义成员变量. ...
- 面向对象编程(OOP)的五大特征-java学习之旅(1)
这是Alan Kay关于第一个成功的面向对象语言SmallTalk的总结: 1.所有的东西都是对象.可将对象想象成一种新型的变量:它保存着数据,但是可要求它对自身进行操作,理论上讲,可从要解决的问题身 ...
随机推荐
- 开发人员使用HANA交付业务的学习路径
本文于2019年7月22日完成,发布在个人博客网站上. 考虑个人博客因某种原因无法修复,于是在博客园安家,之前发布的文章逐步搬迁过来. 入门 编程规范. 开发环境使用方法. 基本语法,与其它同类软件的 ...
- ubuntu环境下因pie选项导致双击启动失败的问题
在ubuntu环境下,链接可执行文件时增加-pie选项,双击可执行程序,无法正常启动. 对于这个现象,stackoverflow有个帖子,gcc creates mime type applicati ...
- 一个库帮你快速实现EF Core数据仓储模式
前言 EF Core是我们.NET日常开发中比较常用的ORM框架,今天大姚要分享的内容是如何使用EF Core Generic Repository通用仓储库来快速实现EF Core数据仓储模式. E ...
- C# sqlclient数据库事务BeginTransaction()详解
重载 重载 BeginTransaction() 开始数据库事务. BeginTransaction(IsolationLevel) 以指定的隔离级别启动数据库事务. BeginTransaction ...
- 【FAQ】HMS Core推送服务推送角标的开发及常见问题解答
目录 1.发送消息并显示桌面数字角标. 2.如何清除数字角标? 3.如何设置圆点角标? 4.应用桌面图标角标开关无法开启或未显示开关. 5.推送消息设置了角标字段但未显示角标? 6.未设置角标参数,但 ...
- Mongoose介绍
官网 Mongoose.js中文网 (mongoosejs.net) 基本使用 安装 最新的是mongoose8.0.0版本,基于Promise,以前的版本是基于回调函数. npm npm i mon ...
- Openstack之工作流程
组件 OpenStack的核心部件即包括Nova(用于计算).Keystone(用于身份服务).Neutron(用于网络和地址管理).Cinder(块存储).Swift(对象存储).Glance(镜像 ...
- Go语言打印九九乘法表，这是整洁代码范例
Go语言打印九九乘法表,这是整洁代码范例 / Go 语言输出九九乘法表 / 九九乘法表是我们学习编程时的一项基本练习,它看似简单,通过实现输出九九乘法表可以加深对 Go 语言循环结构的理解和运用. 本 ...
- 力扣319(java)-灯泡开关（中等）
题目: 初始时有 n 个灯泡处于关闭状态.第一轮,你将会打开所有灯泡.接下来的第二轮,你将会每两个灯泡关闭第二个. 第三轮,你每三个灯泡就切换第三个灯泡的开关(即,打开变关闭,关闭变打开).第 i 轮 ...
- 使用日志上下文聚合插件使能上下文查询及Livetail
简介: 日志上下文浏览是排查业务故障时常用的方式,但受限于Logtail插件系统的设计,在Logtail 1.2.1版本前,如果用户使用Logtail插件来处理日志或采集容器的标准输出,那么用户将无法 ...