Java入门第二章基础知识第三章面向对象的程序设计

74 阅读 0 评论 49 点赞

我是靠谱客的博主迅速西装，最近开发中收集的这篇文章主要介绍Java入门第二章基础知识第三章面向对象的程序设计，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

2020.5.15补充知识

1.用类实例化一个对象后，想要修改对象的某个属性，就需要调用setXXX方法（这个方法需要在类中写一个set函数）
2.被static修饰的变量（静态变量），方法可以被类直接调用而不用用类new一个对象再用对象调用方法。一个类中的方法，如果用不用static修饰，只属于每一个单独的对象，但是如果用static修饰，则属于该类下面全部的对象在这里插入图片描述
3.什么叫方法的重载？在一个类里面定义的方法名相同但是参数不同的方法
4.对象的初始化必须由构造方法完成。构造方法可以有参可以无参，有参的话，在new对象的时候就需要添加参数：Person p = new Person(18) 18就是构造方法里的参数
5.子类继承了父类，父类的方法子类可以直接用，但是父类里在类内部定义的成员变量必须用super继承。继承中实现方法的重写，在子类中在定义一个和父类中方法名一样的方法即可
6.对象的向上转型，是说鱼是动物， Anminal anminal=new Fish()；anminal实际上是一个鱼的对象。不能使用fish类新增的方法和变量。
7.嵌套类：在类中再定义一个类

public class Contents{
	public class contents(){
	int a=10
	}
}

8.匿名类在创建new对象的时候就写类的主体

Person p=new Person(){
	public void method(){
	System.out.print("a");
	}
}

9.（Collection类）Vector：对比于Array，当更多的元素被加入进来以至超出其容量时，Vector的size会动态增长，而Array容量是定死的。同时，Vector在删除一些元素后，其所有下标大于被删除元素的元素都依次前移，并获得新下标比原来的小了)。注意：当调用Vector的size()方法时，返回Vector中实际元素的个数。（好像BufferedString）
10.快速拷贝数组方法通过用System.currentTimeMillis时间对比，确实用arraycopy方法比for循环快点
在这里插入图片描述

 arraycopy（public static void arraycopy(Object src,int srcPos,Object dest,int destPos,intlength)
 /*
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量
*/

11.哈希值好像就是Java里的地址先不做深入了解了
12.DOS命令就是黑框框
13.static double hypot(double x, double y) （Math包里）
返回 sqrt(x2 +y2)，没有中间溢出或下溢。
14.生成随机数的两种方法
① Math.random(); //产生0-1（不含）的随机数
②

Random r=new Random();
		r.nextInt(100);	//产生0-100（不含）的随机int
		r.nextFloat(100); //float类型

15.万物皆可String
String s= String.valueOf( ) //8种类型的值都可以valueOf，还原回来还不是很会
16.获取当前时间

Date date2 = new Date(System.currentTimeMillis() + 1000);
		System.out.println(date2);

第一章程序设计基础

标识符规范

不能以数字开头不能是关键字
变量名和方法名的第一个单词的首字母小写，从第二单词开始每个单词首字母大写
常量名所有字母都要大写，单词之间用下滑线连接 eg： DAY_OF_MONTH
类名首字母都大写，对象名第一个字母小写，后面每个单词首字母大写，方法名第一个字母一般小写

注释
// ：单行注释
“/* +*/” 多行注释加号没有
/** + */ 文档注释加号没有

输出：System.out.println(“Hello world”); //System系统类
System.out.println : 换行输出
System.out.print : 不换行输出
对象方法
有main函数的称为主类
一个java文件只能有一个main函数!类可以有多个，但是public class也只能有一个
建包 package
建类 class
在包里面可以建类适合容易
包里面有很多相似的类，成为一个包
封装
把一个个事物放到类里，再放到包里，适合管理

第二章基础知识

1.基本语法格式
2.[修饰符]class 类名{关键字
程序代码
}

int a=100;
System.out.println("a="+a);//输出a的值

class 声明类，必须用class
类名称通常首字母大写

在这里插入图片描述

强制类型转换

基础知识：

需要定义两个类，一个包含主函数，另一个是别的类


public class 貂蝉 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TypeConversion tConversion=new TypeConversion();	//用类创建对象
		tConversion.operate();								//用对象调用方法
/*TypeConversion是类名，tConversion是对象名，用类创建对象，new是一个关键字
tConversion.operate()是一个方法，用对象调用方法。
*/
	}

}
//--------------------------------------------
public class TypeConversion {
	public static final double MY_CONST=6.89;
	public void operate(){
		char mychar='h';
		byte mybyte=6;
		int myint =100;
		long mylong=89L;
		float myfloat=8.77f;
		double mydouble=6.99;
		int tcint=mychar+myint;
		long tclong=mylong-tcint;
		float tcfloat=mybyte*myfloat;
		double tcdouble=tcfloat/tcint+mydouble;
		System.out.println("tcint="+tcint);		//这个+和后面println()里面的+都表示字符串连接
		System.out.println("tclong="+tclong);
		System.out.println("tcfloat="+tcfloat);
		System.out.println("tcdouble="+tcdouble);
		tcint=(int)tcdouble;
		System.out.println("tcint="+tcint);
		tcint=(int)MY_CONST+(int)mychar;
		System.out.println("tcint="+tcint);
	}
}

IF条件语句

//本程序给定一个成绩，划分通过还是不通过。成绩大于等于60时，输出通过与成绩，繁殖只输出成绩
public class If {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestGrade tGrade=new TestGrade();
		//下面两条语句可以分别注释，以测试不同情况
		tGrade.print60(70);
		tGrade.print60(50);
	}

}
//**********************************
//需要新建一个类
public class TestGrade {		
	public void print60(int grade){
		if(grade>=60){
			System.out.println("通过，成绩为：");
		}
		System.out.println(grade);
	}
}

switch语句


public class switch {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//封装了switch语句的程序
		TestSwitchGrade sGrade=new TestSwitchGrade();
		sGrade.print(79);			//调用函数
		sGrade.print(53);
		sGrade.print(100);
	}

}
//***********************************

public class TestSwitchGrade {
	public void print(int grade){
		int level=grade/10;
		switch(level){
		case 10:
			System.out.println("666");
			break;
		case 9:
			System.out.println("成绩：优秀");
			break;
		case 8:
			System.out.println("成绩：良好");
			break;
		case 7:
			System.out.println("成绩：中等");
			break;
		case 6:
			System.out.println("成绩：及格");
			break;
		default:
			System.out.println("成绩：不合格");
		}
		System.out.println("成绩为:"+grade);
	}
}

For语句


public class While {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SumNumber sNumber=new SumNumber();
		//求自然数1-100之间的偶数之和
		int sEven=sNumber.sumEven(0,100);
		System.out.println("偶数之和="+sEven);
		//求自然数1-100之间奇数的和
		int sOdd=sNumber.sumOdd(1,100);
		System.out.println("奇数之和="+sOdd);
	}

}
//********************************

public class SumNumber {
	//判断某数是否为偶数方法
	public boolean isEven(int aNumber){
		if(aNumber%2==0){
			return true;
		}else{
			return false;
		}
	}

//求任意两个自然数之间的偶数和
public int sumEven(int start,int end){
	int sum=0;
	if(!isEven(start)){
		start+=1;
	}
	for(int i=start;i<=end;i+=2){
		sum+=i;
	}
	return sum;
}
//求任意两个自然数之间的奇数和
public int sumOdd(int start,int end){
	int sum=0;
	if(isEven(start)){
		start+=1;
	}
	for(int i=start;i<=end;i+=2){
		sum+=i;
	}
	return sum;
	}
}
//类里面的public int(boolean,double)是可以相互调用的，不用在乎顺序

while语句


public class While {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//封装了while语句结构的程序
		SumNumberWhile sNumber=new SumNumberWhile();
		//求自然数1-100之间的偶数之和
		int sEven=sNumber.sumEven(0,100);
		System.out.println("偶数之和="+sEven);
		//求自然数1-100之间奇数的和
		int sOdd=sNumber.sumOdd(1,100);
		System.out.println("奇数之和="+sOdd);
	}

}
//*****************************************

public class SumNumberWhile {
	public boolean isEven(int aNumber){
		if(aNumber%2==0){
			return true;
		}else{
			return false;
		}
	}

//求出任意两个自然数之间的偶数的和
public int sumEven(int start,int end){
	int sum=0;
	if(!isEven(start)){
		start+=1;
	}
	for(int i=start;i<=end;i+=2){
		sum+=i;
	}
	return sum;
}
//求出任意两个自然数之间的奇数的和
public int sumOdd(int start,int end){
	int sum=0;
	if(isEven(start)){
		start+=1;
	}
	for(int i=start;i<=end;i+=2){
		sum+=i;
	}
	return sum;
	}
}

Do while


public class Do_while {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SumNumberDoWhile sNumber=new SumNumberDoWhile();
		//求从自然数5开始所有的自然数之和，如果其和刚超过指定数值就停止循环
		sNumber.sum(5,200);
	}

}
//****************************************

public class SumNumberDoWhile {
	public void sum(int start,int end){
		int n=0,sum=start;
		do{
			sum+=n;
			n++;
		}while(sum<=end);
		System.out.println("连续"+n+"个自然数");			//两个+表示连接字符串
		System.out.println("自然数之和="+sum);
	}
}

循环嵌套


public class 循环嵌套 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NestLoop nLoop=new NestLoop();
		nLoop.print(10);
	}

}
//****************************

public class NestLoop {
	//本程序使用循环语句结构的嵌套实现数字三角形的形状
	public void print(int level){
		for(int i=1;i<=level;i++){
			int j=1;
			while(j<=level+1-i){
				System.out.print("  ");
				j++;
			}//内层while循环结束
			for(int m=1;m<=i;m++){
				if(i>=level){
					System.out.print(+i+"  ");
				}else{
					System.out.print(+i+"   ");
				}
			}//内层for循环结束
			System.out.println(" ");
		}//外层for循环结束
	}
}

效果图如下
在这里插入图片描述

九九乘法表

好有自信145*154/cb


public class ninenine {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Nine nNine =new Nine();
		nNine.operate(9);
	}

}
//************************************************

public class Nine {
	public void operate(int n){
		for(int i=1;i<=n;i++){
			System.out.print("n");
			for(int j=1;j<=i;j++){
				System.out.print(j+"*"+i+"="+(i*j)+" ");
			}
		}
	}
}

效果图
在这里插入图片描述

第三章面向对象的程序设计

类和对象


public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ARectangle myRectangle,yourRectangle;//声明对象
		myRectangle =new ARectangle();//	使用new和构造方法为对象实例化和初始化，即分配内存。
		yourRectangle= new ARectangle(30,40);
		ARectangle hisRectangle=new ARectangle(100,200,0,0);
		/*实例变量和类变量的值看最后的赋值是多少，上面两行可以分别注释，展示效下面一行输出的效果*/
		System.out.println(ARectangle.getArea());
	}

}



public class ARectangle {
	static int width,height,x,y;
	public ARectangle(){
		width =0;
		height=0;
	}
	public ARectangle(int width,int height){
		this.width=width;	//局部变量赋值给局部变量
		this.height=height;
		System.out.println("the rectangle's width is "+width+" and the height is "+height);
	}
	public ARectangle(int width,int height,int x,int y){
		this.width=width;
		this.height=height;
		this.x=x;
		this.y=y;
		System.out.println("the rectangle's width is "+width+" and the height is "+height);

	}
	public static int getArea(){	//刚才不能调用成功的关键在于static
		return width*height;
	}
}

main是静态的方法（也叫类方法），只能调用类方法而不能调用非静态方法（即实例方法），上面的关键在于用静态的main方法调用了非静态的getArea方法。只需要把该方法定义为static的即可
注意： width height都要定义为静态变量，不然只能在这个类用而不能在Test类中使用。

类变量由static修饰，可通过类名.类变量名引用，也可同下：
实例变量无static ，只能通过对象名.实例变量引用
类方法与实例方法同理：
实例方法可以调用实例变量和类变量，且可以操作其他实例方法和类方法，
类方法只能调用类变量不能调用实例变量，且只能操作类方法。


public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//封装了实例变量和类变量被引用的程序
		MyLadder aLadder = new MyLadder(3.0f,10.0f,20);
		MyLadder bLadder = new MyLadder(2.0f,3.0f,10);
		MyLadder.bottomSide=200;//类名引用类变量
		System.out.println("aLadder对象的下底为："+aLadder.getBottomSide());
		System.out.println("bLadder对象的下底为："+bLadder.getBottomSide());
		bLadder.setBottomSide(60);//对象名引用类变量
		System.out.println("aLadder对象的下底为："+aLadder.getBottomSide());
		System.out.println("bLadder对象的下底为："+bLadder.getBottomSide());
	}

}



public class MyLadder {
	/*数据成员包括常量，实例变量和类变量，所以在对象引用数据成员时就会有所区别
	 * 一个类通过使用new可以创建多个不同的对象，这些对象被分配不同的内存空间。
	 * 换句话说，不同对象的实例变量将分别属于相应的内存空间，
	 * 这些实例变量是通过对象名.实例变量 被引用
	 *类变量由说static修饰，他是由同类的所有对象共有，即同类的所有对象的这个类变量
	 *都能分配分配相同的一块儿内存空间，改变其中一个对象的这个类变量会影响其他对象
	 *的这个类变量。因此，类变量可以通过 对象名.类变量名 引用，也可以通过 类名.类变量名 引用。
	 */
	/*该类封装了Ladder累，表示实例变量和类变量的引用异同
	 * 两个MyLadder对象共有一个bottomSide类变量
	 */
	private float aboveSide,height;//实例变量
	public static float bottomSide;//类变量
	public MyLadder(float x,float y,float h){
		aboveSide=x;
		bottomSide=y;
		height=h;
	}
	public float getBottomSide(){
		return bottomSide;
	}
	public void setBottomSide(float b){
		bottomSide =b;
	}
}

继承

最后

以上就是迅速西装为你收集整理的Java入门第二章基础知识第三章面向对象的程序设计的全部内容，希望文章能够帮你解决Java入门第二章基础知识第三章面向对象的程序设计所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Java
浏览次数：74 次浏览
发布日期：2023-09-03 09:40:33
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_10_fy_14__23_ky.html

Java入门第二章基础知识第三章面向对象的程序设计

概述

第一章程序设计基础

第二章基础知识

强制类型转换

IF条件语句

switch语句

For语句

while语句

Do while

循环嵌套

第三章面向对象的程序设计

类和对象

继承

最后

评论列表共有 0 条评论

发表评论取消回复

Java入门第二章基础知识第三章 面向对象的程序设计

概述

第一章 程序设计基础

第二章基础知识

强制类型转换

IF条件语句

switch语句

For语句

while语句

Do while

循环嵌套

第三章 面向对象的程序设计

类和对象

继承

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

Java入门第二章基础知识第三章面向对象的程序设计

第一章程序设计基础

第三章面向对象的程序设计

发表评论取消回复