java基础

最新推荐文章于 2022-04-07 00:01:38 发布
最新推荐文章于 2022-04-07 00:01:38 发布
阅读量657 收藏
点赞数
分类专栏： java 学习记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_48445113/article/details/123798785
版权
这篇博客详细介绍了Java中的变量、浮点型运算误差、关系运算符、循环结构、逻辑运算、数组、字符串以及方法的定义和调用。强调了浮点型计算的不精确性，整数与浮点数混合运算时整数会被转换为浮点数，同时探讨了数组的管理和遍历、字符串的比较和操作，以及方法的参数传递和返回值。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. Scanner str = new Scanner(System.in);

  2. 变量

    int we;
we = str.nextInt;//为we赋值

  3. 当浮点数和整数放在一起运算时，java会将整数转换成浮点数，然后进行浮点数的运算。

  4. (int + int/12.0)*0.3048=浮点型

  5. 浮点型：double、float

    double inch；
inch = str.nextInt;//可行，因为，整数是可以用浮点数来表达的。

    浮点型计算是有误差的。

    浮点型计算是有误差的。

  6. 整数类型不能表达有小数部分的数，整数和整数的运算结果还是整数。

  7. 优先级：单目最高，其余与数学无异

  8. 强制转换： 只是从那个变量计算出了一个新的类型的值，它并不改变那个变量，无论是值还是类型都不改变。

    int foot;
foot = (int)(3/3.0);//将浮点型转化为整型

  9. 自动售票机的工作过程： 用户：（1）. 选择线路 （2）. 投入币 过程：1. 初始化 //只有一条路线

    1. 读入投币金额 打印车票

    2. 计算并打印找零 注释：//、/* */、/** */.

  10. 关系运算        ==、！=、>、>=、<、<= (1)、所有的关系运算符的优先级都比算术运算符的低，但是比赋值运算符的高。 （2）、判断是否相等的==和!=的优先级比其他的低，而连续的关系运算是从左到右进行的。 （3）、判断浮点型之间的大小一般采用：该比较的两个数的差是否小于一个比较小的数 Math.abs(f1-f2)<0.00001

  11. 循环 while （1）、读位数 a.判断 1-9,10-99…… b.取余 c.除法 输入的值除以10，进行循环，计数，右往左 (2)、if-判断 while-循环（当条件满足时，我们要不断地重复循环体内的语句。） （3）、do-while 先循环，后判断。[ do{循环体}while（循环条件）; ]

  12. 猜数游戏

  13. /**猜数游戏***/
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner st = new Scanner(System.in);
    int a  ;
    int cou=0;//赋初值
    int b = (int)(Math.random()*100+1);//[0,1)----->[0,100)----->[1,100]
    do {
       a = st.nextInt();//玩家猜入一个数
       cou++;//计数，计算玩家一共猜入了几个数
       if(a>b) {
        System.out.println("偏大");
       }else if(a<b) {
        System.out.println("偏小");
       }
    }while(a!=b);//当a==b，跳出循环，否则，一直循环；
    System.out.print("答对了，恭喜您！！！");
        System.out.print("一共答了： "+ cou+"次");
}

  14. 整数分解

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner st = new Scanner(System.in);
    int number = st.nextInt();//用户输入一个数
    int result=0;//分解结果
    int prossce;//该整数个位上的数值
    do{
        prossce = number%10;//取余，取出该整数个位上的数值
        result = result*10+prossce;//123 ----> 12*10+3 = 123
        number = number/10;//将原个位数上的值取走之后，原十位的值变为个位，重复之前动作直至取完为止
    }while(number>0);//循环条件==>输入的数值最后一位的位置上的数值等于0，则被取完
    System.out.println("则： "+result);
}
    ​

13.For循环

 （1）、N！

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner st = new Scanner(System.in);
        int n = st.nextInt();
        int i=1;
        int factor=1;
        //方法一 while
        /**while(i<=n) {
            factor = factor*i;  //例如 3 ： 1*1  1*2 2*3  [factor*i]
            i++;
        }*/
        //方法二 for
        for(i=1;i<=n;i++) {
            factor = factor*i;
        }
        System.out.print(factor);
    }
14.素数
（1）、只能被1和自己整除的数不包括1


public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sr = new Scanner(System.in);
        int enter = sr.nextInt();
        int j=1;
        for(int i = 2;i<enter;i++) {
            if(enter % i == 0) {
                j=0;
            }
        }
        if(j==1) {
            System.out.println(enter+"是素数！！！");
        }else if(j==0) {
            System.out.println(enter+"不是素数！！！");
        }
    }
（2）、break;结束循环


public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sr = new Scanner(System.in);
        int enter = sr.nextInt();
        int j=1;
        for(int i = 2;i<enter;i++) {
            if(enter % i == 0) {
                j=0;
                System.out.println(enter+"不是素数！！！i= "+i);
                break;
            }
        }
        if(j==1) {
            System.out.println(enter+"是素数！！！");
        }else if(j==0) {
            System.out.println(enter+"不是素数！！！");
        }
    }
​
（3）、continue；结束当前循环进入写一个
（4）、100以内的素数


public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sr = new Scanner(System.in);
        int enter ;
        int n = sr.nextInt();
        for(enter=2;enter<n;enter++) {
            int j=1;
         for(int i = 2;i<enter;i++) {
            if(enter % i == 0) {
                j=0;
                //System.out.println(enter+"不是素数！！！i= "+i);
                break;
            }
        }
        if(j==1) {
               System.out.print(enter + " ");
        }
     }
    }
（5）、前50位素数


public static void main(String[] args) {
        // TODO Auto-generated method stub
       Scanner sr = new Scanner(System.in);
        //int n = sr.nextInt();
        int prime;
        int i;
        int count=1;
        for(int k=2;k<10000;k++) {
            if(count>50) {
                break;
            }
           int j=1;
           for(i=2;i<k;i++) {
            if(k%i==0) {
                j=0;
              }
           }   
           if(j==1) {
                System.out.print(k+"\t");   
                count++;
          }
        }
    }
（6）、标号：
  循环：
       break:\continue:标号
Top: 整个循环结束
例如：攒钱

/*******只出一个方案**********/
public class saveMoney {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sr = new Scanner(System.in);
        int money = sr.nextInt();
        //标号
        OUT:
        for(int one = 0 ; one <= money; ++one) {
            for(int five=0;five<=money/5;++five) {
                for(int ten=0;ten<=money/10;++ten) {
                    for(int twenty=0;twenty<=money/20;++twenty) {
                        if(one+five*5+ten*10+twenty*20==money) {
                            System.out.println(one+"个1元 + "+ five+"个5元+"+ten+"个10元 + "+ twenty+"个20元="+money+"元");
                            break OUT;
                        }
                    }
                }
            }
        }
    }
*********多种结果********
public class saveMoney {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sr = new Scanner(System.in);
        int money = sr.nextInt();
        //标号
        //OUT:
        for(int one = 0 ; one <= money; ++one) {
            for(int five=0;five<=money/5;++five) {
                for(int ten=0;ten<=money/10;++ten) {
                    for(int twenty=0;twenty<=money/20;++twenty) {
                        if(one+five*5+ten*10+twenty*20==money) {
                            System.out.println(one+"个1元 + "+ five+"个5元+"+ten+"个10元 + "+ twenty+"个20元="+money+"元");
                            //break OUT;
                        }
                    }
                }
            }
        }
    }

15.布尔类型 Boolean

（1）、逻辑值 ture\fase

（2）、逻辑运算

    a. 逻辑运算是逻辑量进行的运算，只有逻辑量可以参与运算。

    b.！（非） &&（与/且） ||（或）

    c.区间

    d.优先级

//    ！> && > ||
//  e.egs: sum=1-1/2+1/3-1/4+.......+1/n
package One;
/**
​
 * sum = 1+2+3+4+.......+n
 * sum = 1+1/2+1/3+......+1/n
 * sum = 1-1/2=1/3-1/4.......+1/n
   */
   import java.util.Scanner;
   public class Sequense {
   public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner sr = new Scanner(System.in);
    int n = sr.nextInt();
    //方一
    int sum=0;
    for(int i=1;i<=n;i++) {
        sum+=i;
    }
    System.out.println(sum);
    //方2
    //int m =sr.nextInt();
    double result=0;
    for(int i=1;i<=n;i++) {
        result += 1.0/i;    
    }
    System.out.printf("%.2f",result);
    System.out.println();
    //方三
    double mout=0;
    int sign =1;
    //1
    for(int i=2;i<=n;i++) {
        mout +=sign*1.0/i;
        sign=-sign;
    }
    System.out.printf("%.2f",mout);
    System.out.println();
    //2
    double moutS=0;
    for(int i=1;i<=n;i++) {
        if(i/2==0) {
            moutS+=1.0/i;
        }else {
            moutS-=1.0/i;
        }
    }
    System.out.printf("%.2f",moutS);
   }
   }

    f.输出有规格规定

 System.out.printf("%.2",sum);

（3）、最大公约数

 a.枚举法


public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sr = new Scanner(System.in);
		int a = sr.nextInt();
		int b = sr.nextInt();
		int result=0;
		for(int i =1;i<=a && i<=b;i++) {
			if(a%i==0 && b%i==0) {
				result=i;
			}
		}
		System.out.println(a + "和" + b + "的最大公约数是： " +result);
	}
  b.辗转相除法

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner se = new Scanner(System.in);
		int a = se.nextInt();
		int b = se.nextInt();
		int r ;
		int as=a;
		int bs=b;
		System.out.println("a"+"\t"+"b"+"\t"+"r");
		while(b!=0) {
			r = a%b;			
			System.out.println(a+"\t"+b+"\t"+r);
			a=b;
			b=r;
		}
		System.out.println(as + "和" + bs + "的最大公约数是： " + a);
	}

16.数组

（1）、数组

a.读入数组

b.计算平均数

c.输出大于平均值的数

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner se = new Scanner(System.in);
		int [] array=new int[100];
		int x = se.nextInt();
		int result=0;		
		int count=0;
		double ave=0;
		while(x!=-1) {
			array[count]=x;
			result+=x;
			count++;
			x=se.nextInt();
		}
		if(count>0) {
			for(int i=0;i<=count;i++) {
				//System.out.println("该数组为："+array[i]);
		        ave = result/count;
				if(array[i]>ave) {
					System.out.println("大于平均值的数有："+array[i]);
				}
			}
		    System.out.println("平均值：" + ave);
		}
	}

（2）、创建数组

   a. 数组是一种容器

   b.特点：所有元素具有相同的数据类型； 一旦创建，不能改变大小；

   c.<类型>[]<名字>=new<类型>[元素数量];

    元素个数必须是整数；

    元素个数必须给出；

    元素个数可以是变量；

/**动态决定数组大小**/
public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner se = new Scanner(System.in);
        System.out.println("请输入数组的大小：");
        int count = se.nextInt();
        int result=0;
        double ave;
        int [] array = new int[count];
        for(int i =0;i<count;i++) {
            array[i]= se.nextInt();
            result +=array[i];
        }
        ave = result/count;
        for(int i =0;i<count;i++) {
            if(array[i]>ave) {
                System.out.println(array[i]);
            }
        }
        System.out.println("总和：" + result);
        System.out.println("平均值：" + ave);
    }
​

d.索引或下标从0开始（同C） 最小从0开始，最大总个数-1 d.length（长度）==>数组总长度 每个数组有一个内部成员length，会告诉你它的元素的数量

17.数组变量

（1）、数组变量是数组的管理者而非本身；

（2）、数组必须创建出来然后交给数组变量来管理；

（3）、数组变量之间的赋值是管理权限的赋予；

（4）、数组变量之间的比较是判断是否管理同一个数组；

（5）、复制数组 必须遍历原数组将每个元素逐一拷贝给目的数组。

18.遍历数组

（1）、通常使用for循环，让循环变量i从0到数组length,这样循环体内最大的i正好是数组最大的有效数下标

（2）、FOR-EACH循环
 

for(int k:data){ 

// data是数组 ...... 

}//解释：对于数组data中的每一个元素，（取出来作为k的变量）作为循环的每一轮赋予k，k值在变，循环第一轮k=data[0],第二轮k=data[1].......；

//适合于遍历数组 ------->结构------> for(<类型><变量>:<数组>){ ... }

（3）、sqrt(n):n的平方根

19.构造素数表

20.二维数组

21.字符类型

（1）、char char a = ‘a’;=2;=‘加’；

（2）、逃逸字符 用来表达无法印出来的控制字符或特殊字符，它由一个反斜杠“\”开头，后面跟上另一个字符，这两个字符合起来，组成一个字符。 ----->\b 回退一格 "双引号 \t 到下一个表格位 '单引号 \n 换行 \反斜杠本身 \r 回车

（3）、包裹类型 每种基础类型都有对应的包裹类型,第一个字母必须是大写 -->boolean Boolean char Character int Integer double Double

a.好处---获得该类型的最大/最小值 Integer.MIN_VALUE Integer.MAX_VALUE

b. .运算符 当需要让一个类或对象做事情时，用.运算符

22.MATH类

abs 绝对值 Math.abs(-12) pow

密次 Math.pow(2,3)

random随机数 Math.random()*100 round

四舍五入 Math.round(10.672)

23.字符串

（1）、用双引号括起来的0个或者多个字符就是一个字符串字面量

（2）、字符串变量： String s; String是一个类，String 的变量是对象的管理者而非所有者。 （3）、创建： new=创建 String s = new String("a String"); 例如：String s = new String("hello"); （4）、初始化字符串变量 String s = "hello";

（5）、字符串链接 a.+

egs: String s =new String("Hello");
     System.out.println(s+" world");
     result: Hello world

（6）、输入字符串 

 Scanner in = new Scanner(System.in);
   in.next();  //读入一个单词，单词的标志是空格；
   in.nextLine();  //读入一整行

       空格包括：空格、tab、换行

（7）、对象变量的赋值 egs:

String a;String b; // a=b
          //a 和

     b 必须管理同一个变量

（8）、比较两个字符串String

    a. 比较是否指向同一个（是否管理同一个字符串）

    b. 比较内容是否相同 比较用： .equals 比较内容是否相同

（9）字符串操作

  A、字符串是对象，对它的操作都是通过“.”这个运算符进行的

  B、字符串.操作

  C、表示：对.左边的这个字符串做右边的那个操作

  D、此字符串可以是变量也可以是常量

 E、比较大小：

     s1.compareTo(s2)

  a.如果s1比s2小，那么结果是负的

  b.如果s1和s2相等，那么结果是0

  c.如果s1比s2大，那么结果是正的 ==> compareToIgnoreCase 可以不区分大小写地来比较大小  F、length()函数： 获得字符串长度

G、s.charAt(index) 访问字符串里的字符

  a.返回在index上的单个字符;

  b.index的范围是0到length()-1;

  c.第一个字符的index是0，和数组一样

  d.不能用for-ench循环来遍历字符串

H、得到子串

  a. s.substring(n) 得到：从n号位置到末尾的全部内容

  b. s.substring(b,e) 得到：从b号位置到e号位置之前的内容

I、寻找字符

  a. s.indexOf(c) 得到： c字符所在的位置，-1表示不存在

  b. s.indexOf(c,n) 从n号位置开始寻找c字符

  c. s.indexOf(t) 找到字符串t所在的位置

  d.从右开始找： s.lastIndexOf(c） s.lastIndexOf(c,n) s.lastIndexOf(t)

J、其他

s.startsWith(t) : 是否以t开头

s.endsWith(t) ：是否以t结尾

s.trim() : 删除字符串两端的空格

s.replace(c1,c2): 将字符串中所有的c1都换成

c2 s.toLowerCase() : 将所有字符变成大写字母

s.toUpperCase() : 将所有字母都换成小写

K、switch-case 中可使用字符串（在1.7版本及以上可使用） 

switch(s){
                 case "this":......break;
                 case "this":......break;
                 }

=====> 所有的字符串都是不可变的，对它们的操作的结果都是制造新的字符串出来

24.方法（函数）

（1）、函数的定义与调用（类c）

     main 程序入口

     函数头{ 函数体 } 函数头： public static 返回类型 函数名（参数表）

     参数表：类型 变量，类型 变量，类型......

（2）、调用函数

   a.函数名（参数值）；

   b.()起到了表示函数调用的重要作用

   c.即使没有参数也需要()

   d.如果有参数，则需要给出正确的数量和顺序

   e.这些值会被按顺序依次用来初始化函数中的参数

   f.从函数中返回值 return g.调入函数时传入值类型必须匹配 char—>int—>double 宽的接受窄的       h.没有返回值 void

   i.可以传递给函数的值是表达式的结果： 字面量 变量 函数的返回值 计算的结果

   j.传值 每个函数都有自己的变量空间，参数也位于这个独立的空间中，和其他函数没有关系

     形参：对于函数参数表中的参数 ==参数

     实参：调用函数时给的值 ==值

25.本地变量

（1）、函数的每次运行，就产生了一个独立的变量空间，在这个空间中的变量，是函数的这次运行所独有的，称做本地变量

（2）、本地变量：定义在函数内部的变量（参数亦是）

（3）、变量的生存期和作用域

       a.生存期： 出现-消亡

       b.作用域： 在（代码的）什么范围内可以访问这个变量（这个变量可以起作用）

       c. 对于本地变量：大括号内---块

 for(int i=1;i<19;i++){
  }
  for(int i=1;i<19;i++){
  }

（4）、本地变量定义在块内 ===>{内}

【JavaSE】知识点总结：方法
qq_53869058的博客
02-10 300
方法定义:一段可以被重复执行的代码块​public static 返回值类型 方法名称(形参类型 形参名称 ...){// 方法体定义[return 返回值]​无返回值时返回值类型用viod形参:定义方法时的参数称为形参 形式参数，不知道具体数值，但是规定好了类型实参: 调用方法时向方法传递的具体数值，称为实参调用方法，方法名称(参数)实参和形参的传递过程只有值传递(实参赋值给形参的过程只是把实参的值拷贝一份给形参!实参和形参互不干扰，两个独立的实体)
《Java基础入门（第3版）》（Java）：课后答案-docx文档
最新发布
01-27
《Java基础入门（第3版）》是一本针对Java初学者的教材，其课后答案文档提供了对书中习题的解答，旨在帮助读者巩固所学知识。Java是一种面向对象的编程语言，具备跨平台性，由Java虚拟机（JVM）负责解释执行。Java...
factor java_dfactor
weixin_35924719的博客
02-28 330
示例在github可见，链接最新监听集群内结点事件api 示例集群内广播功能 示例集群间通信(包括rpc)多种序列化格式支持,String,Json,byte[],ByteBuf,自定义序列化对象 示例增加集群内结点间rpc调用 示例， 本地actor间rpc调用 示例集群功能上线，去中心化自动组网，集群内结点互相发现互相通信 入门示例开发中js脚本开发支持dfactordfactor 是一...
factor java_Java Hashtable factor 0.75
weixin_29099729的博客
03-06 131
今天在看spring源码是，发现有一处代码是这样写的(代码位置3.0.5 package org.springframework.jndi下JndiTemplate 129行)：protected Context createInitialContext() throws NamingException {Hashtable icEnv = null;Properties env = getEnv...
factor java,将字符变量更改为factor
weixin_29887959的博客
03-13 357
我有一个R脚本，有时可以工作，有时不工作，我已经确定问题是与我的角色有关 - >因素转换，然后我将两个数据集合并在一起 .我有一个在data1中编码为'1'，'2'，'3'等的主题列表，在data2中有'01'，'02'，'03'等，我想重新编码参与者data1中的数字以匹配data2 . 我首先尝试将data1 $ subj转换为一个因子，然后使用forcats中的fct_recode重新...
第四章JAVA方法的使用
一名在校大三学习JAVA
04-07 758
什么是方法 JAVA中的方法就是一段代码段，类似于C语言中的函数 是能够模块化的组织代码(当代码规模比较复杂的时候 让代码更好的理解 直接调用现有的方法，不需重复造轮子 能做到代码的重复使用，相同的代码在多个位置使用 方法的定义和调用 1. public 和 static 两个关键字在此处具有特定含义, 后面会介绍 2. 方法定义时, 参数可以没有. 每个参数要指定类型 3. 方法定义时, 返回值也可以没有, 如果没有返回值,...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
《Java基础入门》-课后习题答案.doc
01-01
本文将对《Java 基础入门》课后习题答案进行总结，涵盖了 Java 基础知识点，包括 Java 开发入门、Java 基础类、变量类型、运算符、控制流语句、方法重载等。 一、Java 开发入门 * Java EE、Java SE、Java ME 是 ...
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始学习的JAVA基础到高级学习教程，对于有JAVA基础的同学来说可以略过前面的JAVA基础章节，直接学习后续的JAVA高级部分课程。更可以灵活的作为章节技术，进行针对性的JAVA学习。还是要...
《Java基础入门》课后习题及答案
03-23
《Java基础入门》课后习题及答案
Java方法的认识
qq_63512251的博客
03-21 466
一、什么是方法 二、 三、 四、
初学java 3.基本输入输出
PRIME__FACTOR的博客
05-11 349
1. java有一个专门用于处理数据输入的Scanner类，Scanner类位于java.util.包中，在使用它的程序中需要import这个包。2. Scanner类主要包括一下方法：   String nextLine();   String next();   int nextInt();   long nextLong();   float nextFloat();   double ne...
【java设计模式】之 工厂（Factory）模式
武哥聊编程
04-23 3万+
1.工厂模式的定义         工厂模式使用的频率非常高，我们在开发中总能见到它们的身影。其定义为：Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation t...
java实现数字反转（逆序输出）
热门推荐
龟的小号的博客
11-03 4万+
要求：输入一个整数，将这个数字逆序输出（数字反转） 例如：输入3251，需输出1523 package com.number.test; import java.util.Scanner; /** * 数字反转（输入3251，需输出1523) */ public class NumberReverse { public static void main(String[] args)...
Factor
zhangxiaojiakele的博客
04-28 6750
关于R语言中的”因子”变量类型(一) 使用R语言一段时间的用户绝对不会对R语言中的因子变量类型(factor)感到陌生,我想很多人与因子类型打交道最常见的渠道便是在使用read.table(), read.csv()等函数读取文件时一不小心将字符 串类型的数据转化为因子类型,导致后面的数据处理中出现各种潜在的问题,丈二和尚摸不着头脑.事实上.R语言自带读取函数中的这一设置为很多人所诟病,也正是这...
java代码----实现因子分析算法
ITzym的博客
10-25 1759
许久没有管自己的博客了，问我要源码的亲们，现在可以看了，希望可以帮到你们。 代码如下： import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util...
java多线程总结
PRIME__FACTOR的博客
09-01 212
        在java中有两种创建线程的方式，分别是继承Thread类和实现Runnable接口。用同一个实现了Ruannale接口的对象为参数创建多个线程时，多个线程共享该对象中的数据。这是一种实现线程间通信的方法。         线程可以分为前台线程和后台线程。后台线程又叫守护线程或者辅助线程，它是一种低级线程，无法阻止程序结束。并且在后台线程中启动的其他线程均为后台线程。      ...
Java编程--简单的Factory程序（工厂设计模式）
小猪的日常Java
06-05 4643
Factory类不是接口、抽象类，就是普通的类。Factory就像一个工厂一样，可以返回很多对象。子类在继承、实现抽象类和接口后由Factory类处理，由于子类可能会有多个，Factory根据客户端的调用返回不同的子类对象。代码实现。定义接口定义一个Fruit接口，里面有一个getName()抽象方法。package factory; /** * 定义接口 * 2018-05-19 */ p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值