基于eclipse的java基础（一）

最新推荐文章于 2023-03-22 19:22:12 发布

weixin_42675851

最新推荐文章于 2023-03-22 19:22:12 发布

阅读量422

点赞数

分类专栏： Java 文章标签： java eclipse

本文链接：https://blog.csdn.net/weixin_42675851/article/details/119352697

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.1HelloJava

/**文档注释，会被读取为javadoc的内容
 * @author Administrator
 *
 */
public class HelloJava1 {

	/**
	 * 123
	 */
	public HelloJava1() {
		// TODO Auto-generated constructor stub存根
	}

	/**
	 * @param args 
	 * 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("什么是java语言："+"〇开发工具：笔（IDE）"+"①程序源代码（菜单）预处理→"+
		"②编译器（大厨切菜）解释→"+"③字节码（美食半成品即切好的菜）解释→"+"④JVM（大厨做饭）"+
		"⑤机器码（出锅）→计算机");
		System.out.println("java版本："+"SE:标准版，桌面应用程序开发。EE:企业级分布式网络程序。"
		+ "ME:嵌入式系统开发");
		System.out.println("syso+alt+/");
        System.out.println("alt / 代码提示自动补全");
        System.out.println("debug进行调试，断点所在，"
        		+ "单步跳入f5进入该行代码，查看该代码如何运行，查看详细的运行过程 ，单步跳过f6");
	} 

}

2.1主类结构

public class First_ZhuLeiJieGou1 {//公开类名，java的基本组成是类，类中包含属性和方法
	//文件名必须和文件名相同，区分大小写，如class不等于Class
	static String s1="你好";//类的属性=全局变量（成员变量）
	public First_ZhuLeiJieGou1() {//公开名字
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {//程序开始执行的位置
		//主类（主方法），权限修饰符，静态修饰符，返回值修饰符，字符串类型数组为参数
		// TODO Auto-generated method stub
		String s2="java";//方法中的属性，局部变量
		System.out.println(s1);
		System.out.println(s2);
	}

}

2.2数据类型

public class Number_ShuJuLeiXing2 {//创建类
	public Number_ShuJuLeiXing2() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		/*基本数据类型为、数值型（整数类型、浮点类型）、字符型（+转义字符）、布尔型
		*整数类型（byte 8位约127、short16约三万二、int32约正负21亿四千万、long64）
		*浮点类型（float32位、double64，默认double）
		*float f1=123.456f；（要加f）double f2=123.456
		*/
		byte a1=127;
		short a2=32767;
		int a3=21;
		long a4=1;
		System.out.println(a1+a2+a3+a4);
		/*字符型（char占16位2字节）char='a',单引号。"a"代表字符串
		*字符和整数可以换，char word='d';输出(int)word
		*/
		char word='d';
		System.out.println((int)word);
		//转义字符：\开头，后加一个或多个字符。不同于字符原有的含义，故称转义。
		//\t垂直制表符，\r回车，\n换行，\b退格，\f换页
		char c1='\\';//反斜杠的写法
		char c2='\u2605';//四位十六进制数据表示的字符
		System.out.println(c1);
		System.out.println(c2);
		
		/*布尔类型又叫逻辑类型，只有真假，不能和整数类型进行转换。
		 * 
		 */
		
		boolean b=true;//定义布尔类型b,赋予初值true
	}

}

2.3常量变量

public class Variable_Constant3 {
	static final double PI=3.14;//final成员变量
	/*5.成员变量
	 * 在类中定义的变量为成员变量，成员变量在整个类中都有效。
	 * 分为静态变量和实例变量。静态变量的有效范围可以跨类。
	 */
	int x;//实例变量
	static int y;//静态变量
	
	public Variable_Constant3() {
		// TODO Auto-generated constructor stub
	}
	
	
	public static void main(String[] args) {
		/*1.标识符（名字）：标识类名，变量名，方法名，数组名，文件名；
		 * 第一个字符不是数字，由字母，下划线，数字，$组成。
		 * 类名：通常使用名词，所有单词首字母大写如 Variable_Constant
		 * 方法名：使用动词，首单词字母小写，后边大写如  openDoor
		 * 变量名：名词，首单词字母小写，后边大写如 sisiterName
		 * 常量名：都大写如 GENDER 性别（非必须）
		 * 关键字是被赋予特别意义的字，如 int
		 */
		
		/*2.声明变量
		 * 定义变量就是告诉编译器这个变量的数据类型，编译器会知道：分配多少空间，存放什么数据；
		 * 程序运行中，空间中的值是变化的，这个内存空间称为变量，内存空间内的值为变量值。
		 * 声明变量时可以赋初始值，可以不赋值。
		 * 内存大致分为系统区，程序区，数据区。程序执行时，代码加载到程序区，数据在数据区。
		 */
		int age;
		char char1='r';
		/*3.常量：程序运行中，一直不变的量。也叫final变量
		 * 当定义的final变量属于成员变量时，定义是就要设定初值。
		 */
		final int age1;
		
		
		/*4.变量的有效范围指的是代码能够访问该变量的区域，超出编译错误。
		 * 根据有效范围分为成员变量和局部变量。
		 * 局部变量指在方法体中定义的变量。只在方法中有效
		 * 局部变量可以和成员变量重名，此时此方法体中成员变量失效
		 */
	}
}

2.4运算符

public class YunSuanFu4 {

	public YunSuanFu4() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		//1.赋值运算符
		int a,b,c;
		a=15;
		c=b=a+4;
		System.out.println(c);
		//2.算术运算符,加减乘除取余
		float d1=45.56f;
		int d2=152;
		System.out.println("加减乘除");
		System.out.println((d1+d2));
		System.out.println((d1-d2));
		System.out.println((d1*d2));
		System.out.println((d1/d2));
		System.out.println((d1%d2));
		//3.比较运算符
		System.out.println("比较");
		System.out.println((d1>d2));
		System.out.println((d1<d2));
		System.out.println((d1==d2));
		System.out.println((d1>=d2));
		System.out.println((d1<=d2));
		System.out.println((d1!=d2));
		//4.自增自减运算符
		int e1=3,e2=4;
		e1=e2++;
		System.out.println("自增自减");
		System.out.println(e1);
		System.out.println(e2);
		e1=--e2;
		System.out.println(e1);
		System.out.println(e2);
		//5.逻辑运算符
		int f1=3,f2=4;
		System.out.println("逻辑");
		boolean f3=((a>b)&&(a<b));
		boolean f4=((a>b)||(a<b));
		boolean f5=(!((a>b)||(a<b)));
		System.out.println(f3);//与
		System.out.println(f4);//或
		System.out.println(f5);//非
		//6.按位运算符
		int f6=f1&f2;//3是011，4是100，则按位与000
		int f7=f1|f2;//3是011，4是100，则按位或为111为7
		int f8=~f1;//3是011，按位取反100
		int f9=f1^f2;//3是011，4是100，则按位异或111，相同为0不同为1
		System.out.println("按位");
		System.out.println(f6);
		System.out.println(f7);
		System.out.println(f8);
		System.out.println(f9);
		//7.移位运算符
		System.out.println("移位");
		int f10=f1>>1;//011右移一位01
		int f11=f2>>1;//100右移一位10
		int f12=f1<<1;//011左移一位110
		int f13=f1>>>1;//011无符号右移一位01
		System.out.println(f10);
		System.out.println(f11);
		System.out.println(f12);
		System.out.println(f13);
		//8.三元运算符
		boolean g=20<30?true:false;
		//若结果为真，选择true，则整体结果为1，若结果为假，返回false，则取2
		
		/*运算符优先级
		 * ()>正负号>一元运算符>算术运算符>移位运算符>比较运算符
		 * >按位运算符>逻辑运算符>三元运算符>赋值运算符
		 */
		
		//类型转换：一个值从一个类型转换成另一个类型
		int x=50;
		float y=x;//隐式转换
		System.out.println(y);
		long x1=(long)456.5f;//显式转换
		System.out.println(x1);
	}
}

3.1流程控制-复合-条件语句

//复合语句以块{}为单位，由{开始，}结束。为局部变量创造了一个作用域。
public class FuHeYuJu_TiaoJian1 {

	public FuHeYuJu_TiaoJian1() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		//条件语句，可能有多个条件，但是一个条件对应一个结果
		int a=45;
		int b=12;
		if(a>b) {//布尔表达式，必要参数
			System.out.println("a>b");//语句序列，可选参数，若只有一句，可省略{}
		}
		//if……else if多分支语句
		int c=20;
		if(c>30) {
			System.out.println("c的值大于30");
		}else if(c>25) {
			System.out.println("c的值大于25小于30");
		}else if(c>10) {
			System.out.println("c的值大于10小于25");
		}else {
			System.out.println("c的值小于10");
		}
		//switch多分支语句，多个条件对应多个结果，一一对应。
		//表达式的值必须是整型，字符型，字符串类型
		//先计算表达式的值，如果表达式的值和某个case后面的常量值相同，则
		//执行case中的若干语句，直到遇到break为止，若表达式的值没有与case中的值相等
		//执行default
		String str="nihao";
		switch(str) {
		case"ni":
			System.out.println("ni");
		case"hao":
			System.out.println("hao");
		case"nihao":
			System.out.println("nihao");
		default:
			System.out.println("都不是");
		}
	}
}

3.2 循环语句

public class XunHuanYuJu_2 {

	public XunHuanYuJu_2() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		/*循环语句：条件控制
		 * 利用一个条件来控制是否继续反复执行这个语句
		 * 条件表达式返回为真，执行语句序列，为假时，退出循环
		 */
		//1.while语句
		int a=1,sum=0;//初始条件
		while(a<=10) {//循环条件
			sum=sum+a;//执行的语句序列
			++a;//让循环终止的条件
		}
		System.out.println("将1-10累加结果为"+sum);
		
		//2.do while语句，先执行一次语法序列，在判断是否循环
		int b=100;
		do {
			System.out.println("ok");
			b--;
		}
		while(b==60);
		//3.for循环 for（初始化，循环条件，让循环终止的条件）执行语句序列
		int sum1=0;
		for(int i=2;i<=100;i=i+2) {
			sum1=sum1+i;
		}
		System.out.println("2到100偶数和为"+sum1);
		//4.foreach循环遍历
		int arr[]= {1,7,10};
		for(int x:arr) {
			System.out.println(x);
		}
		//5.双循环
		for(int p=0;p<3;p++) {
			for(int q=0;q<6;q++) {
				if(q==4)
					break;//跳出当前循环体
				System.out.println("p="+p+"q="+q);
			}
		}
		//6.跳出外层循环Loop
		Loop:for(int u=0;u<3;u++) {
			  	for(int v=0;v<6;v++) {
			  		if(v==4)
			  			break Loop;
			  		System.out.println("u="+u+"v="+v);
			}
		}
		//7.continue跳出循环,跳过本次循环结束前的语句，回到循环条件，重新循环
		//20以内奇数
		for(int y=1;y<20;y++) {
			if(y%2==0)
				continue;
			System.out.println(y);
		}
	}
}

4.1字符串类

import javax.print.attribute.standard.DateTimeAtCompleted;

public class String_lei1 {

	public String_lei1() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		//1.创建并连接字符串
		String s0="hello";//开辟空间s0，存放hello地址，指向内存中的hello
		String s1="hello";//开辟空间s1，存放hello地址，指向内存中的hello
		String s2=new String("word");//s2指向新对象中的word
		String s3=s1+" "+s2;
		System.out.println(s3);
		System.out.println("i like"
				+" java");
		//连接其它数据类型
		int hour=2;
		System.out.println("我每天花费"+hour+"个小时练习"+s3);
		//获取字符串长度
		int size=s0.length();
		System.out.println(size);
		//2.搜索的字符或字符串第一次和最后一次出现的位置
		int size1=s0.indexOf('l');
		System.out.println(size1);
		int size2=s0.lastIndexOf('l');
		System.out.println(size2);
		//3.获取指定索引位置的字符
		char mychar=s3.charAt(6);
		System.out.println(mychar);
		//4.截取字符串
		String s4=s3.substring(3, 5);
		System.out.println(s4);
		//5.去除前后空格
		String s5=" java nihao ";
		System.out.println(s5.length());
		System.out.println(s5.trim().length());
		//6.字符串替换
		String s6=s5.replace('j','J');
		System.out.println(s6);
		//7.前后缀判别
		boolean b=s5.startsWith("ja");
		boolean b1=s5.endsWith("o ");
		System.out.println(b);
		System.out.println(b1);
		//8.字符串相等判断,比较运算符判断的是内存地址
		boolean b2=(s0==s1);
		System.out.println(b2);
		String s7=new String("hello");
		String s8=new String("Hello");
		boolean b3=(s0==s7);
		System.out.println(b3);
		boolean b4=(s7.equals(s8));
		System.out.println(b4);
		boolean b5=(s7.equalsIgnoreCase(s8));//不区分大小写
		System.out.println(b5);
		//9.大小写转换
		String a="abc DEF";
		System.out.println(a.toLowerCase());
		System.out.println(a.toUpperCase());
		//10.字符串分割str.split("分割字符"，分割次数)
		//数组是引用数据类型，数组名是数组的管理者，而非所有者。
		//访问数组元素时，可for循环遍历数组。
		//基本数据类型放在栈内存上，引用数据类型在堆内存上
		String[] s9=s7.split("e", 2);
		for(String d:s9 ) {
		System.out.println(d);
		} 
		
	}
}

4.2 正则

public class ZhengZe2 {

	public ZhengZe2() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		
		/*正则表达式，通常被用于判断语句，检查某一字符串是否满足格式要求。
		 * 具有特殊意义的字符串，成为元字符，如\d代表任意数字.\D代表任何一个非数字字符.\s任意空白字符,
         *\S代表任意非空字符.\w代表可用作标识符的字符,\W代表不可用作标识符的字符.\p{Lower}代表26小写字母.
         *\p{Upper}代表大写字母.\p{punct}代表标点符号。元字符在正则中在加一个\才是正则中的写法。
         *.是正则中的任意字符，所以如果要用.必须转义为\.
         *在正则中用[]括起来若干字符表示一个元字符。
		 * 限定修饰符：？0或1次.* 0或多次. + 至少一次.{n,}至少n次.如A?.A+.A*.A{2}.A{2,}.A{2,6}
		 */
         //在正则表达式中，两个\代表其他语言中的一个\
		//判断邮箱名是否合法{邮箱名@服务器名称（.中间名）.后缀}
		String regex="\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";
		String str="456xiao@163.vip.com";
		if (str.matches(regex))
			System.out.println("合法！");
		/*字符串生成器
		 * 创建成功的字符串，其长度是固定的，内容不能改变和编译，用+可以达到附加新字符或
		 * 字符串的目的，但会产生一个新实例，会在内存中创建新的字符串对象，如果重复修改，
		 * 极大地增大了系统开销。
		 * 字符串生成器的方法可以动态的增append(content)，尾部追加内容
		 * 删delete(int start,int end)，
		 * 插insert(int offset,arg)操作。
		 * toString最后输出字符串结果
		 */
		StringBuilder bf=new StringBuilder(hello);
		bf.insert(5, "world");
		System.out.println(bf.toString());
		/*
		 * 字符串内部其实就是一个使用final关键字定义的char[]数组，
		 * 数组长度一旦声明则不可改变，字符串一旦声明则不可改变，改变的引用内存指向。
		 * 赋值操作只是改变了变量引用内存区域的位置，而没有改变那块内存中的数据内容。
		 * 
		 * 基本数据类型是名字和内容是存放在栈中的；是变量，单纯的值
		 * 可以在源数据的基础上发生改变,内存地址不会发生改变
		 * 
		 * 引用数据类型名字存放在栈中，内容存放在堆中；是对象，不可以在源数据的基础上发生改变,
		 * 如果想要通过某些运算或者方法来改变源数据,则会重新开辟空间存储结果,并不会影响源数据
		 */
	}
}

5.1数组-创建使用

import java.util.Arrays;

public class ChuangJianShiYong1 {

	public ChuangJianShiYong1() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		/*数组是具有相同数据类型的一组数据的集合。
		 * 是引用数据类型，首先声明数组类型，其次在为它分配内存空间，分配时必须指明数组长度
		 */
		//int arr[];声明数组类型arr[]=new int[5]为数组分配内存
		int arr[]=new int[] {1,2,3};//声明数组类型并分配内存初始化
		for (int i = 0; i < arr.length; i++) 
			System.out.println(arr[i]);//不能直接输出数组
		System.out.println(Arrays.toString(arr));
		
		
		for (int i : arr)
			System.out.println(i);//引用数据类型转化成基本数据类型输出
		//二维数组的创建遍历
		int a[][]=new int[][]{{1,2},{3,4},{5}};
		for (int j = 0; j < a.length; j++) {
			for(int k=0;k<a[j].length;k++)
				System.out.println(a[j][k]);
			System.out.println( );		
		}
		//System.out.println(Arrays.toString(a));二维不能用
		int u=0;//计数器
		for(int x[]:a) {//外层遍历
			u++;//=1
			int v=0;
			for(int y:x) {//内层遍历
				v++;//=1
				if(u==a.length && v==x.length) {//终止条件
					System.out.println(y);
				}else
					System.out.println(y+"、");
				
			}
		}
		

	}
}

5.2基本操作

import java.util.Arrays;

public class JiCao2 {

	public JiCao2() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//填充替换数组
		int a[]=new int[2];
		Arrays.fill(a, 8);
		for(int b=0;b<a.length;b++) {
			System.out.println(a[b]);
		}
		//填充第一个索引，不包括第二个
		Arrays.fill(a, 0, 1, 2);
		for(int c=0;c<a.length;c++) {
			System.out.println(a[c]);
		}
		//升序排序
		int d[]=new int[]{3,8,3};
		Arrays.sort(d);
		System.out.println(Arrays.toString(d));
		for(int e=0;e<d.length;e++) {
			System.out.println(d[e]);
		}
		//复制数组
		int f[]=Arrays.copyOf(d, 5);
		System.out.println(Arrays.toString(f));
		int g[]=Arrays.copyOfRange(d,0,1);//有范围复制
		System.out.println(Arrays.toString(g));
	    //查询
		Arrays.sort(d);//先排序，才能准
		int index=Arrays.binarySearch(d, 3);//查询值得索引
		System.out.println(index);
		int index1=Arrays.binarySearch(d,0,2,3);//查询值得索引，中间0,2表示范围
		System.out.println(index1);
	
	}

}

5.3BubbleSort

public class BubbleSort3 {

	public BubbleSort3() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		int[] arr= {63,4,1,3,15};
		
		for(int i=1;i<arr.length;i++) {//总共进行length-1轮次
			for(int j=0;j<arr.length-i;j++) {//每趟交换length-i次
				if(arr[j]>arr[j+1]) {
					//交换
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		//for(int q:arr)
			//System.out.print(q+" ");
		BubbleSort.ShowArray(arr);//调用类的静态方法无需创建对象
				
					
	}
}

5.4SelectSort

public class SelectSort4 {

	public SelectSort4() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		int[] a= {63,4,24,1,3,15};
		SelectSort(a);
	}
	//每次比较找出最大的，放在后边，然后进行下一趟比较
	public static void SelectSort(int[] arr) {
		int index;
		for(int i=1;i<arr.length;i++) {//一共比较length-1趟，6个比较5趟
			index=0;
			//每趟比较length-i次，第1趟比较5次，先找出每次比较最大的
			for(int j=1;j<=arr.length-i;j++) {
				if(arr[j]>arr[index])
					index=j;
			}
			//将最大的放在后边
			int temp=arr[arr.length-i];
			arr[arr.length-i]=arr[index];
			arr[index]=temp;
		}
		ShowArray(arr);
	}
	public static void ShowArray(int[] arr) {
		for(int i:arr)
			System.out.print(i+" ");	
	}
}

5.5RverseSort

public class RverseSort5 {

	public RverseSort5() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		int q=7;
		System.out.println(q/2);
		int[] a= {63,4,24,6,1,3,15};
		sort(a);
	}
	/*
	 * 第i个元素和第length-i-1交换
	 */
	public static void sort(int[] arr) {
		int temp;
		int len=arr.length;
		for(int i=0;i<len/2;i++) {//从0开始的   0.1.2
			temp=arr[i];
			arr[i]=arr[len-i-1];
			arr[len-i-1]=temp;
			
		}
		ShowArray(arr);	
	}
	public static void ShowArray(int[] arr) {
		for(int i:arr)
			System.out.print(i+" ");	
	}
}

6.1类

public class Class1 {

	public Class1() {
		
		/*对象是事物存在的实体，将对象划分为两部分，静态和动态
		 * 1.静态部分指对象的属性（如人的高矮胖瘦，性别），即成员变量
		 * 2.动态部分指对象的行为（行走，哭泣），即方法
		 * 面相对象程序设计把实体抽象成对象，然后考虑这个对象具有的属性和行为。
		 * 识别出对象的属性和行为后，对象就被定义完成了。
		 * 类实质上是封装对象属性和行为的载体，对象则是类抽象出来的实例。
		 * 类是同一类对象的统称。
		 */
		/*封装：将属性和行为封装起来
		 *继承：利用特定对象之间的共有属性。如正方形继承了父类四边形的某些特性。
		 *多态：四边形有好多儿子，如长方形，平行四边形，调用父类可更方便处理。
		 */
	}
	public static void main(String[] args) {
		/*3.局部变量：成员方法内定义的变量，方法执行时创建，执行完销毁，必须赋值或初始化
		 * 作用域：互不嵌套的作用域中可以同时声明两个名称和类型相同的变量。如两个for
		 * 相互嵌套的作用域中不可以。如 有一个局部变量，for中有重名的
		 */
		
		/*
		 * 4.this:当成员变量和局部变量重名时，
		 * 将参数值赋值给类中的成员变量。或将成员变量值赋值给参数值
		 * 调用构造方法 eggcake
		 *
		// 5.构造方法:创建类的对象过程中运行的方法，对象的初始化方法,可以加参数
		//没有返回值，对象的构造就是构造方法完成的
		//当类实例化一个对象时，类自动调用构造方法，给对象做初始化用的
		/*6.权限修饰符：private本类可见，protected同包可见，public其他包的类可见
		 * 声明类时无修饰符权限，则默认包存取范围。
		 */
		/*7.static修饰的变量、常量、方法存于静态区（共享区）中，和程序生命周期一样长 
		 * 共享变量就是用static修饰，就是静态变量如pool
		 * final static修饰常量，就是静态常量，所有类共享，所在类.常量名 可以引用，例子PI
		 * 调用类的静态方法无需创建对象
		 * static修饰代码区域称为静态代码块，优先运行如test
		 */
		/*8.主方法：类的入口点，java编译器通过主方法执行程序
		 * 主方法是静态的，调用的方法也必须是静态的，不是静态方法必须创建对象实例
		 * 主方法没有返回值
		 * 主方法的形参为数组，args[0]到args[n]代表程序的第一个到第n个参数
		 */
		/*9.对象：Test a=new Test(1);//声明一个对象，用new操作符调用构造方法
		 * 特殊例子String str="abc";str也是一个对象
		 * a是一个引用，存放的对象的内存地址，后边的new Test(1)才是对象 可以直接用
		 * 创建对象后，可用 对象.类成员 获取对象的属性和行为，如new Test(1).类成员
		 */
	}
}

6.2EggCake

public class EggCake {
	int eggcount=3;
	public EggCake(int eggcount) {
		//this.eggcount=eggcount;//将参数值赋值给类中的成员变量。同10.1super
		System.out.println("这个饼里有"+eggcount+"个鸡蛋");//加上this都是3
	}
	public EggCake() {
		this(2);
		//eggcount=1;
		//System.out.println("这个饼里有"+eggcount+"个鸡蛋");
	}
	public static void main(String[] args) {
		EggCake a=new EggCake();
		EggCake b=new EggCake(5);
		
	}
}

6.3Pool

public class Pool {
	static public int water=0;
	public void outlet() {
		if(water>2) {
			water=water-2;
		}else
			water=0;
	}
	public void inlet() {
		water=water+3;	
	}	
	public static void main(String[] args) {
		Pool out=new Pool();
		Pool in=new Pool();
		System.out.println("水池中现在的水量"+water);
		in.inlet();
		in.inlet();
		System.out.println("注水两次水池中现在的水量"+water);
		out.outlet();
		System.out.println("放水一次水池中现在的水量"+water);
		//说明water是公用的，in和out都对他造成了影响
    }
}

6.4Test

public class Test {
	{
		System.out.println("这里是非静态代码块");
	}
	static {
		System.out.println("这里是静态代码块");
	}
	
	public Test(int x) {
		System.out.println("这里是构造方法");
	}
	public void method() {
		System.out.println("这里是成员方法");
	}
	public static void main(String[] args) {
		//不创建实例只运行静态代码块
		Test a=new Test(1);//声明一个对象，用new操作符调用构造方法
		//特殊例子String str="abc";str也是一个对象
		a.method();//不调用不运行
		//new Test(1).method();
	}
}

7.1包装类-Integer

public class Integer1 {
	//包装类：从基本数据类型可以生成对象，在基本数据类型中可以调用一些方法
	/*将基本类型的值包装在一个对象中
	 * Number类，是BigDecimal,BigInteger,Byte,Shorter,Long,Float,Double
	 * 的父类，子类必须提供将表示的数值转换为各自数据类型的方法，
	 * 如intValue（），以int形式返回指定的数值
	 * 
	 */
	public Integer1() {
		//integer类有两种构造方法，同Double,Float，Byte类
		//Integer(int value)
		//Integer(String str)，必须是数值型字符串
		
		/*布尔类构造方法
		 * Boolean(boolean value)
		 * Boolean(String str)
		 */
		/*Byte类将基本类型为byte的值包装在一个对象中
		 * Byte(byte value)
		 * Byte(String str),要用数值型string作为参数
		 */
		//Character类
		//Character(char value)
	}

	public static void main(String[] args) {
		Integer number=new Integer(5);
		Integer number1=new Integer("20");
		System.out.println(number);
		System.out.println(number1.intValue());
		String str[]= {"12","13","14"};
		for(String i:str) {
			int a=Integer.parseInt(i);//将字符串中的数字转化成int值
			System.out.println(a);
		}
		//返回一个表示integer值得string对象
		String str1= Integer.toString(456);
		System.out.println(str1);
		int a=Integer.MAX_VALUE;//最大 值
		System.out.println(a);
		
		Boolean b1=new Boolean(true);
		Boolean b2=new Boolean("ok");
		Boolean b3=new Boolean("true");
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
		System.out.println(b1.compareTo(b2));
		System.out.println(b1.booleanValue());
		System.out.println(b2.toString());
	}

}

8.1Decimal_Format

import java.text.DecimalFormat;//放在最上边，否则编译错误
public class DecimalFormat1 {
	/*
	 * 数字格式化操作主要针对的是浮点型数据，double和float
	 * DecimalFormat是NumberFormat的一个子类，用于格式化十进制数字
	 */
	
	public DecimalFormat1() {
		
	}
	//数字格式化函数
	static public void SFormat(String pattern, double value) {
		DecimalFormat a=new DecimalFormat(pattern);//有参（格式化模式）构造函数
			String output=a.format(value);//格式化数值
			System.out.println(value+" "+pattern+" "+output);		
	}
	//数字格式化函数
	static public void APFormat(String pattern, double value) {
		DecimalFormat b=new DecimalFormat();//无参构造函数
		b.applyPattern(pattern);//赋予格式化模式
		System.out.println(value+" "+pattern+" "+b.format(value));	
		
	}
	public static void main(String[] args) {
		DecimalFormat b=new DecimalFormat();
		SFormat("###,###.###",123456.789);
		APFormat("##.###kg",1234.5678);
		//声明一个对象，对对象实行一个方法，将得到的结果返回给一个返回类型变量输出
		DecimalFormat c=new DecimalFormat();
		c.setGroupingSize(3);//设置数字分组
		//c.setGroupingUsed(false);不允许设置数字分组
		String output=c.format(123456.789);
		System.out.println(output);
	
	
	}
}

8.2Decimal_Math

import java.util.Random;
import java.math.BigDecimal;
public class Math2 {
	
	public Math2() {
		//math中有众多数学函数方法，他们被定义为static形式，在程序中可直接调用
	}
	
	public static void main(String[] args) {
	//取整函数 构造函数   public static double ceil（double a）；
		System.out.println("返回一个大于等于参数的整数"+Math.ceil(5.7));
		System.out.println("返回最接小于等于参数的整数"+Math.floor(5.7));
		System.out.println("返回一个最接近参数的整数"+Math.rint(5.4));
		System.out.println("返回一个四舍五入长整型整数"+Math.round(5.4));
	//取最值	构造函数   public static int max（int a，int b）；
		System.out.println("取最大值"+Math.max(4,8));
		System.out.println("取最小值"+Math.min(4,8));
		System.out.println("取绝对值"+Math.abs(-4.2));
	//三角函数
		System.out.println("cos60度为"+Math.cos(Math.PI/3));
	//随机数  Random r=new Random(seedvalue);随机数生成器种子
		System.out.println("随机产生0-1double数"+Math.random());
		Random r=new Random();//需要包
		System.out.println("随机产生大于0小于2整数"+r.nextInt(2));
		System.out.println("随机产生一个双精度值"+r.nextDouble());
	//BigDecimal 支持任何精度的定点数
		//构造方法：public BigDecimal（double val）；
		//           public BigDecimal（string val）;
		
		Math2 d=new Math2();
		System.out.println(d.add1(7.5, 8.6));
		
	}
	public  BigDecimal add1(double value1,double value2) {
		BigDecimal b1=new BigDecimal(Double.toString(value1));
		BigDecimal b2=new BigDecimal(Double.toString(value2));
		return b1.add(b2);//调用加法方法
	}
}

weixin_42675851

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
基于eclipse的java基础（一）

1.1helloJava/**文档注释，会被读取为javadoc的内容 * @author Administrator * */public class HelloJava1 { /** * 123 */ public HelloJava1() { // TODO Auto-generated constructor stub存根 } /** * @param args * */ public static void main(String[] arg
复制链接

扫一扫