java第六章总结

最新推荐文章于 2022-08-27 16:49:48 发布

I坤坤

最新推荐文章于 2022-08-27 16:49:48 发布

阅读量337

点赞数

文章标签： eclipse java

本文链接：https://blog.csdn.net/m0_63841730/article/details/124231722

版权

1.对象：在现实世界中，随处可见的一种事物就是对象，对象是事物存在的实体，如：人类，书桌，计算机，高楼大厦等。

对象的属性：静态部分

对象的行为：动态部分

2.类：是同一类事物的统称，类实质是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例

3. 面向对象程序设计的特点

封装性、继承型、多态性

封装：封装是面向对象编程的核心思想。将对象的属性和行为封装起来。采用封装的思想保证了类内部数据结构的完整性。

继承：类与类之间同样具有关系，继承性主要利用特定对象之间的共有属性，注意子类的实例都是父类的实例，但不能说父类的实例是子类的实例。

多态：多态的实现并不依赖具体类，而是依赖于抽象类和接口。
4.定义类：

class 类名称{
//类的成员变量
//类的成员方法
}

在java中对象的属性以成员变量的形式存在，对象的方法以成员方法的形式存在。

5.成员变量：在java中对象的属性称为成员变量

数据类型 变量名称 [=值];

java中常见类型的默认值

6.成员方法：在java语言中，成员方法对于类对象的行为，它主要用来定义类可执行的操作，它是包含一系列语句的代码块。

1.成员方法的定义
[权限修饰符] [返回值类型] 方法名 ([参数类型 参数名]) [throws 异常类型]{
...//方法体
return 返回值;
}
其中，"权限修饰符"可以是private、public、protected中的任一个，也可以不写，主要用来控制方法的访问权限，关于权限修饰符将在下一章详细讲解 "返回值类型"指定方法返回数据的类型，可以是任何类型，如果方法不需要返回值，则使用void关键字；一个成员方法既可以有参数，也可以没有参数，参数可以是基本类型中的任何一个。

注意：方法的定义必须在某个类中，定义方法时如果没有指定权限修饰符，方法的访问权限为默认（即只能在本类及同一个包的类中进行访问）。

如果定义的方法有返回值，则必须使用return关键字返回一个指定类型的数据，并且返回值类型要与方法返回的值类型一致

2.成员方法的参数

调用方法时可以给该方法传递一个或多个值，传给方法的值叫做实参，在方法内部，接收实参的变量叫做形参，形参的声明跟变量的声明一样，形参只在方法内部有效。java中方法参数主要有3种，分别为值参数、引用参数和不定长参数。

值参数：表明实参与形参之间按值传递，当使用值参数的方法被调用时，编译器为形参分配存储单元，然后将对应的实参的值复制到形参中，在方法中对值类型的形参的修改并不会影响实参。
public class test1 {
	int x ;//定义一个整型变量
	public static void main(String[] args) {//主方法
		test1 book=new test1();//创建Book对象
		int x=30;//定义实参变量x
		int y=40;//定义实参变量y
		System.out.println("运行结果："+book.add(x,y));//输出运行结果
		System.out.println("实参x的值："+x);//输出实参x的值
		
		
		
		
	}
	private int add(int x,int y)//计算两个数的和
	{x=x+y;//对x进行加y操作
	return x;//返回x
		
	}
 
}
运行结果：

2.引用参数

如果在给方法传递参数时，参数的类型是数组或者其他引用类型，那么，在方法中对参数的修改会反映到原有的数组或者其他引用类型上，这种类型的方法参数称为引用参数。
public class RefTest {//类名
 
	public static void main(String[] args) {//主方法
		RefTest refTest=new RefTest();//创建RefTest对象
		int[]i={0,1,2};//定义一维数组，作为方法的实参
		System.out.print("原始数据：");//输出内容
		for(int j=0;j<i.length;j++){//遍历数组
			System.out.print(i[j]+" ");//输出数组元素
		}
 refTest.change(i);//调用方法改变数组元素的值
 System.out.print("\n修改后的数据：");//输出信息
 for(int j=0;j<i.length;j++){//遍历数组
	 System.out.print(i[j]+" ");//输出数组元素
 }
	}
public void change(int[]i){//给数组赋值的方法
	i[0]=100;//给数组与元素赋值
	i[1]=200;//给数组与元素赋值
	i[2]=300;//给数组与元素赋值
}
}
运行结果：

3.不定长参数

声明方法时，如果有若干个相同类型的参数，可以定义为不定长参数，该类型的参数声明如下：
权限修饰符 返回值类型 方法名(参数类型...参数名)
注意：参数类型和参数名之间是三个点，而不是其他数量或省略号
public class MultiTest {//类名
 
	public static void main(String[] args) {//主方法
		MultiTest multi=new MultiTest();//创建MultiTest对象
		System.out.print("运算结果："+multi.add(20,30,40,50,60));//输出信息并调用计算总和方法
		
			}
	int add(int...x){//定义add方法，并指定不定长参数的类型为int
				int result=0;//定义一个整型变量
				for(int i=0;i<x.length;i++){//遍历数组
					result+=x[i];//将数组中元素的值相加
			
		}
		return result;//返回运算结果
	}
 
}
运行结果：

注意：不定长参数必须是方法中的最后一个参数，任何其他常规参数必须在它前面。

7.成员方法的使用

public class Leopard {//类名
	public void gaze(String target){//凝视，目标是参数target
		System.out.println("猎豹凝视："+target);//输出信息
	}
	public void run(){//奔跑
		System.out.println("猎豹开始奔跑");//输出
	}
	public boolean catchPrey(String prey){//捕捉猎物，返回捕捉是否成功
		System.out.println("猎豹开始捕捉"+prey);//输出
		return true;//返回成功
	}
	public void eat(String meat){//吃肉，参数是肉
		System.out.println("猎豹吃"+meat);//输出
	}
	public void sleep(){//睡觉
		System.out.println("猎豹睡觉");//输出
	}
	public static void main(String[]args){//主方法
		Leopard liebao=new Leopard();//在Leopard创建一个对象
		liebao.gaze("羚羊");//调用gaze方法
		liebao.run();//调用run()方法
		liebao.catchPrey("羚羊");//调用catchPrey方法
		liebao.sleep();//调用sleep方法
		
		
	}
}

运行结果：

8.构造方法：

在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。

构造方法的特点如下：

（1）构造方法没有返回类型，也不能定义为void。

（2）构造方法的名称要与本类的名称相同。

（3）构造方法的主要作用是完成对象的初始化工作，它能把定义对象的参数传给对象成员。

构造方法的定义语法如下：
class Book {
public Book(){//构造方法
}
}
public:构造方法修饰符。

Book:构造方法的名称。

在构造方法中可以为成员变量赋值，这样当实例化一个本类的对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，则编译器会自动创建一个不带参数的默认构造方法。除此之外，在类中定义构造方法时，还可以为其添加一个或者多个参数，即有参构造方法语法如下：
class Book {
public Book(int args){//有参构造方法
//对成员变量进行初始化
}
}
构造方法除了可以用public修饰以外，还可以用private修饰，即私有的构造方法，私有构造方法无法使用new创建对象，这时需要使用静态方法生成类对象。
public class BookTest {//类名
	private BookTest(){//私有构造方法
	}//静态公开方法，向图书馆借书
	static public BookTest libraryBorrow(){//创建静态方法，返回本类实例对象
		System.out.println("通过调用静态方法创建对象");//输出信息
		return new BookTest();//返回本类实例对象
	}
 
	public static void main(String[] args) {//主方法
		BookTest book=BookTest.libraryBorrow();//创建一个书的对象，不是new实例化的，而是通过方法从图书馆借来的
	}
 
}
运行结果：

局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。

局部变量在方法被执行时创建，在方法执行结束时销毁。局部变量在使用时必须进行赋值操作或则被初始化，否则会出现编译错误。

public String getName(){//定义一个getName()方法
int id=0;//局部变量
setName("java");//调用类中其他方法
return id+this.name;//设置方法返回值

说明：类成员变量和成员方法可以统称为类成员。如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量的访问以局部变量进行。

局部变量的有效范围

局部变量的有效范围从该变量的声明开始到该变量的结束为止。

在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量。但是相互嵌套不能。

9. 对象的创建

在java语言中通过new操作符来创建对象。前文在讲解构造方法时介绍过。

语法如下：
Test test=new Test();
Test test=new Test("a");
Test:类名。

test:创建Test类对象

new:创建对象操作符。

a:构造方法的参数。

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，
public class CreateObject {//类名
public CreateObject(){//构造方法
	System.out.println("创建对象");//输出信息
}
	public static void main(String[] args) {//输出信息
		
new CreateObject();//创建对象
	}
 
}
运行结果：

10.访问对象的属性和行为

用户在使用new操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。前面提到，对象的属性和行为在类中通过类成员变量和成员方法的形式来表示，所以当对象获取类成员时，也相应地获取对象的属性和行为。

11.对象的销毁

每个对象都有生命的周期，当对象的生命周期结束时，分配给该对象的内存地址会被回收。在其它语言中需要手动回收废弃的对象，但在Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收站将回收无用的但占用内存的资源。

何种对象会被Java虚拟机视为垃圾。

（1）对象引用超出其作用范围，这个对象将被视为垃圾

（2）将对象赋值为null。

finalize()方法可进行垃圾回收但不一定会发生

System.gc()方法强制启动垃圾回收器。

12.this关键字

调用成员变量和方法。

public class Book2 {//创建一个Book类
String name="abc";//定义一个成员变量
public void showName(String name){//定义一个showName类并从传入一个参数
	System.out.println(name);//输出
}
	public static void main(String[] args) {
		Book2 book=new Book2();//在Book2类定义一个对象
		book.showName("123");//调用showName方法
 
	}
 
}

运行结果：

public class Book3 {//类名
String name="abc";//创建一个成员变量
public void showName(String name){
	System.out.println(this.name);//调用成员变量并输出
}
	public static void main(String[] args) {
		
Book3 book=new Book3();//创建对象
book.showName("123");//调用showName方法
	}
 
}

运行结果：

this关键字除了可以调用成员变量和方法，事实上this还可以调用类中的构造方法。

public class EggCake {//类名
int eggCount;//鸡蛋灌饼里有几个蛋
public EggCake(int eggCount){
	this.eggCount=eggCount;
	System.out.println("这个鸡蛋灌饼里有"+eggCount+"个蛋");
}//无参数构造方法，默认给饼加一个蛋
public EggCake(){//方法名
	this(1);
}
	public static void main(String[] args) {//主方法
		EggCake cake1=new EggCake();//在EggCake里创建一个对象
		EggCake cake2=new EggCake(5);//在EggCake里创建一个对象
		
 
	}
 
}

运行结果：

注意：在无参构造方法中可以使用this关键字调用有参的构造方法。但是要注意，this（）语句之前不可以有其他代码。

13.static关键字

由static修饰的变量、常量和方法被称作静态变量、静态常量、静态方法，也被称为类的静态成员。静态成员是属于类所有的。区别于个别对象。

1.静态变量：把共享的变量用static 修饰，该变量就是静态变量。

类名.静态类成员

public class Pool {//类名
static public int water=0;//定义一个静态的公开的整型变量并赋值
public void outlet(){//放水，一次放出2个单位
	if(water>=2){
		water=water-2;//水量减2
	}else{
		water=0;//水量为0
	}
}
public void inlet(){//注水，一次注入3个单位
	water=water+3;//水量加3
}
	public static void main(String[] args) {
		Pool out=new Pool();//在Pool类里创建一个对象
		Pool in=new Pool();//在Pool类里创建一个对象
		System.out.println("水池的水量："+Pool.water);//输出信息
		System.out.println("水池注水两次。");//输出信息
		in.inlet();//调用注水方法
		in.inlet();//调用注水方法
		System.out.println("水池的水量："+Pool.water);//输出信息
		System.out.println("水池放水一次");//输出信息
		out.outlet();//调用防水方法
		System.out.println("水池的水量："+Pool.water);//输出信息
	}
 
}

运行结果：

public class StaticVariable {
	static int x;//静态变量
	int y;//普通成员变量
public StaticVariable(int x,int y){//构造函数
	this.x=x;//调用静态变量并初始化
	this.y=y;//调用成员变量并初始化
}
	public static void main(String[] args) {//主方法
		StaticVariable a=new StaticVariable(1,2);//在类里创建一个对象并赋值
		StaticVariable b=new StaticVariable(13,17);//在类里创建一个对象并赋值
		System.out.println("a.x的值是="+a.x);//输出
		System.out.println("a.y的值是="+a.y);//输出
		System.out.println("b.x的值是="+b.x);//输出
		System.out.println("b.y的值是="+b.y);//输出
 
 
	}
 
}

运行结果：

说明：当类首次被加载时，静态变量就被分配到内存中，直到程序结束才会释放。

2.静态常量

final static 数据类型 变量名=值;

public class Graphical {
final static double PI=3.1415926;//创建静态常量Π
	public static void main(String[] args) {
		double radius=3.0;//半径
				double area=Graphical .PI*radius*radius;//计算面积
				double volume=4/3*Graphical.PI*radius*radius*radius;//计算体积
				Circular yuan=new Circular(radius,area);//在类里创建一个对象
				Spherical qiu=new Spherical(radius,volume);//在类里创建一个对象
	}
 
}
class Circular{
	double radius;//半径
	double area;//面积
	public Circular(double radius,double area){
		this.radius=radius;//调用变量并初始化
		this.area=area;//调用变量并初始化
		System.out.println("圆的半径："+radius+",圆的面积："+area);//输出信息
	}
}
class Spherical {
	double radius;//半径
	double volume;//体积
	public Spherical(double radius,double volume){
		this.radius=radius;//调用变量并初始化
		this.volume=volume;//调用变量并初始化
		System.out.println("圆的半径："+radius+",圆的体积："+volume);//输出信息
	}
}

运行结果：

注意：给静态常量赋值时所有的字母都应该大写。

3.静态方法

类名.静态方法();

public class StaticMethod {
	static public void show(){
		System.out.println("静态方法无需实例化就可以调用");//输出信息
	}
 
	public static void main(String[] args) {
		
		StaticMethod.show();//使用类名调用静态方法
	}
 
}

运行结果:

4.静态代码块

在类中除成员方法之外，用static修饰代码块可以称之为静态代码块。定义一块静态代码块，可以完成类的初始化操作，在类声明时就会运行。

public class StaticTest{
static{
//此处编辑执行语句
}
}

public class StaticTest {
static String name;//定义静态变量
static{
	System.out.println(name+"静态代码块");//输出
}
{
	System.out.println(name+"非静态代码块");//输出
}
public StaticTest(String a){
	name=a;
	System.out.println(name+"构造方法");//输出
}
public void method(){
	System.out.println(name+"成员方法");//输出
}
	public static void main(String[] args) {
		StaticTest s1;
		StaticTest s2=new StaticTest("s2");//new的时候才会运行构造方法
		StaticTest s3=new StaticTest("s3");
		s3.method();//只有调用的时候才会运行
	}
 
}

运行结果：

说明：

（1）静态代码块由始至终只运行一次

（2）非静态代码块，每创建对象时候，会在构造方法之前运行。所以读取成员变量时，只能获取到默认值null。

14.类的主方法

public static void main(String[]args){
//方法体
}

1）主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须是静态的。

（2）主方法没有返回值。

（3）主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n+1个参数，可以使用args.length获取参数的个数。

public class TestMain {
 
	public static void main(String[] args) {//定义主方法
		for(int i=0;i<args.length;i++){//根据参数个数做循环操作
			System.out.println(args[i]);//循环打印参数内容
		}
 
	}
 
}

运行结果：