JAVA语言的特性 - 咕噜咕噜哈里
JAVA语言的特性
1.类的私有成员与公共成员
①私有成员
a.什么是私有成员？
如果没有一个机制来限制对类中私有成员的访问，则有可能造成错误的输入。为了防止种情况的发生，
java语言提供了私有成员访问控制修饰符private.也就是说，如果在类的成员声明的前面加上修饰符private，
则就无法从该类的外部访问到该类内部成员，而只能被该类自身访问和修改，而不能被任何其他类（包括该类的子类）
获取或引用，因此达到了对数据最高级别保护的目的。
例子：
class Cylinder{ //定义Cylinder类 private double radius; //将成员变量 radius 声明为私有成员
private int height; //将成员变量 height 声明为私有成员
private double pi = 3.14; //将成员变量 pi 声明为私有成员，并赋值
double area(){
return pi * radius * radius;
}
double volume(){
return area() * heinght;
}
}
public class {
public static void main(String[] args){
Cylinder volu;
volu = new Cylinder();
volu.rakdius = 2.8;
volu.height = -5;
System.out.println("底圆半径 = "+volu.radius);
System.out.println("圆柱的高 = "+volu.height);
System.out.print("圆柱 ");
System.out.println("底面积 = "+volu.area());
System.out.println("圆柱体体积 = "+volu.volume());
}
}
②公有成员
什么是共有成员？
既然在类的外部无法访问到类内部的私有成员，那么java就必须提供另外的机制，使得私有成员
得以通过这个机制来提供外界访问。解决此问题的办法就是创建公共成员。为此，java提供了公共访问
控制符 public 。如果在类的成员声明的前面加上修饰符 public ，则表示该成员可以被其他的类所访问。
由于 public 修饰符会造成安全性和数据封装的下降，所以一般应减少公共成员的使用。
例子：
class Cylinder{ //定义公共方法来访问私有成员 private double radius; //声明私有成员变量
private int height;
private double pi = 3.14
public void setCylinder(double r,int h){ //声明具有两个参数的公共方法
if(r > 0 & h>0){ //用于对私有成员变量进行访问
radius = r;
height = h;
}
else
System.out.println("您的数据有错误！！")；
}
double area(){
return pi * radius * radius; //在类内可以访问私有成员 radius 和 pi
}
double volume(){
return area() * height; //在类内可以访问私有成员 height
}
puclic class{ //定义公共主类
public static void main(String[] args){
Cylinder volu = new Cylinder();
volu.setCylinder(2.5,-5); //通过公共方法setCylinder()访问私有数据
System.out.printlin("圆柱底面积 = " + volu.area());
System.out.printlin("圆柱体体积 = " + volu.volume());
}
}
}
您的数据有错误！！
圆柱底面积 = 0.0
圆柱体体积 = 0.0
③缺省访问控制符
若在类成员的前面不加任何访问控制符，则该成员具有缺省的访问控制特性，这种缺省访问控制符权表示这个成员只能被
同一个包（类库）中类所访问和调用，如果一个子类与其父类位于不同的包中，子类也不能访问父类中的缺省访问控制成员，也就是说其他
包中的任何类都不能访问缺省访问控制成员。同理，对于类来说，如果一个类没有访问控制符，说明它具有缺省访问控制特性。
2.方法的重载
方法的重载是实现“多态”的一种方法。在面向对象的程序设计语言中，有一些方法的含义相同，但带有不同的参数，这些方法使用相同的名字，这种方法就叫做重载。
也就是说，重载是指同一个类内具有相同名称的多个方法，这多个同名方法如果参数个数不同，或者是参数个数相同但类型不同，则这些同名方法就具有不同的功能。
例子：
class Cylinder{ private double radius;
private int height;
private double pi = 3.14;
private String color;
public double setCylinder(double r,int h){ //重载方法
radius = r;
height = h;
return r+h;
}
public void setCylinder(String str){ //重载方法
color = str;
}
public void show(){
System.out.println("圆柱的颜色为："+color);
}
double area(){ //定义缺省访问控制符的方法
return pi * radius * radius;
}
double volume(){ //定义缺省访问控制符的方法
return area() * height;
}
}
public class { //定义主类
public static void main(String[] args){
double r_h;
Cylinder volu = new Cylinder();
r_h = volu.setCylinder(2.5,5); //设置圆柱的底半径
volu.setCylinder ("红色")； //设置圆柱的颜色
System.out.println("圆柱底半径与高之和 = "+r_h);
System.out.println("圆柱体体积 = "+volume.volume());
volu.show();
}
}
圆柱底半径与高之和 = 7.5
圆柱体体积 = 98.125
圆柱的颜色为：红色
3.构造方法
构造方法是一种特殊的方法，它是在对象被创建时初始化对象成员的方法。构造方法的名称必须与它所在的类名相同。构造方法没有返回值，
但在定义构造方法时，构造方法名前不能用修饰符 void 来修饰，这是因为一个类的构造方法的返回值类型就是该类本身。构造方法定义后，创建对
像是就会自动调用它，因此构造方法不需要在程序中直接调用，而是在对象创建时就会自动调用它，因此构造方法不需要在程序中直接调用并执行。
例子：
class Cylinder{ //定义类Cylinder private double radius;
private int heigareaht;
private double pi = 3.14;
public Cylinder(double r,int h){ //定义有参数的构造方法
radius = r;
height = h;
}
double area(){
return pi * radius * radius;
}
double volume(){
return area() * height;
}
}
public class {
public static void main(String[] args){
Cylinder volu = new Cylinder(3.5,8); //调用有参构造方法
System.out.println("圆柱底面积 ="+volu.area());
System.out.println("圆柱体体积 ="+volu.volume());
}
}
圆柱底面积 =38.465
圆柱体体积 =37.72
构造方法的特殊性：
1）构造方法的方法名与类名相同；
2）构造方法没有返回值，但不能写void；
3）构造方法的主要作用是完成对类对象的初始化工作；
4）构造方法一般不能由编程人员显式地直接调用，而是用 new 来调用；
5）在创建一个类的对象的同时，系统会自动调用该类的构造方法为新对象初始化。
②默认构造方法
如果省略构造方法，java编译器会自动为该类生成一个默认的构造，程序在创建对象时会自动调用默认的构造方法。
默认的构造方法没有参数，在其方法体中也没有任何代码，即什么也不再做。如果Cylinder类没有定义构造方法，则
编译系统会自动为其生成默认的构造方法：
Cylinder(){}如果 class 前面有 public 修饰符，则默认的构造方法也会是 public 的。
③构造方法的重载
一般情况下，每个类都有一个或多个构造方法。由于构造方法与类同名，所以当一个类有多个构造方法时，则这多个构造方法可以重载。
class Cylinder{ private double radius;
private int height;
private double pi = 3.14;
String color;
public Cylinder(){
radius = 1;
height = 2;
color = "绿色"；
}
public Cylinder(double r,int h,String str){
radius = r;
height = h;
color = str;
}
public void setCorlor(){
System.out.println("该圆柱的颜色为："+color);
}
double area(){
return pi * radius * radius;
}
double volume(){
return area() * height;
}
}
public class{
public static void main(String[] args){
Cylinder volu1 = new Cylinder();
System.out.printl("圆柱 1 底面积 ="volu1.area());
System.out.printl("圆柱 1 体积 ="volu1.volume());
volu1.setColor();
Cylinder volu2 = new Cylinder(2.5,8,"红色")；
System.out.printl("圆柱 2 底面积 ="volu2area());
System.out.printl("圆柱 2体积 ="volu2.volume());
volu2.setColor();
}
}
圆柱 1 底面积 =3.14
圆柱 1 体积 =6.28
该圆柱的颜色为：绿色
圆柱 2 底面积 =19.625
圆柱 2 体积 =157.0
该圆柱的颜色为：红色
②从一个构造方法内调用另一个构造方法
为了某些特定的运算，java语言允许在类内从某一个构造方法内调用另一个构造方法。
从某一个构造方法内调用另一个构造方法，是通过使用 this() 语句来调用的。
例子：在圆柱体类Cylinder 内用一个构造方法调用另一个构造方法。
class Cylinder{ private double radius;
private int height;
private double pi = 3.14;
String color;
public Cylinder(){ //定义无参构造方法
this(2.5,5."红色")； //this 语句来调用另一个构造方法
System.out.println("无参构造方法被调用了")；
}
public Cylinder(double r,int h,String str){ //定义有三个参数的构造方法
System.out.println("有参构造方法被调用了")；
radius = r;
height = h;
color = str;
}
public void show(){
System.out.println("圆柱底半径为："+radius);
System.out.println("圆柱体高为："+height);
System.out.println("圆柱的颜色为："+color);
}
double area(){
return pi * radius * radius;
}
double volume(){
return area() * height;
}
public class{
public static void main(String[] args){
Clinder volu = new Cylinder();
Syetem.out.println("圆柱底面积 = "+volu.area());
Syetem.out.println("圆柱体体积 = "+volu.volume());
volume。show();
}
}
}
无参构造方法被调用了
有参构造方法被调用了
圆柱底面积 = 19.625
圆柱体体积 =98.125
圆柱底半径为：2.5
圆柱体高为：5
圆柱的颜色为：红色
③公共的构造函数与私有的构造方法
构造方法一般都是公共（public）的，这是因为它们在创建对象时，是在类的外部被系统自动调用的。如果构造方法被声明为private，
则无法在该构造方法所在的类以外的地方被调用，但在该类的内部还是可以被调用的。
例子：创建圆柱类Cylinder,并在该类的一个构造方法内调用另一个私有的构造方法。
class Cylinder{ private double radius;
private int height;
private double pi = 3.14;
String color;
private Cylinder(){ //定义私有的构造方法
System.out.println("无参构造方法被调用了")；
}
public Cylinder (double r,int h,String str){ //定义有三个参数的构造方法
this(); //在公共构造方法中用 this() 语句来调用另一个构造方法
radius = r;
color = str;
}
public void show(){
System.out.println("圆柱底面半径为："+radius);
System.out.println("圆柱体的高为："+height);
System.out.println("圆柱的颜色为："+color);
}
double area(){
return pi * radius * radius;
}
double volume(){
return area()* height;
}
}
public class{ //主类
public static void main(String[] args){
Cylinder volu = new Cylinder(2.5,5,"蓝色")；
System.out.println("圆柱底面积 ="+volu.area());
System.out.println("圆柱体体积 ="+volu.volume());
volu.show();
}
}
注意：由于声明为private的构造方法无法在类外被调用，但因私有的无参构造Cylinder()与公共的带参数的构造方法Cylinder(double r,int h,String str)是在一个类内，
而在同一类内是可以访问私有成员的。
4.静态成员
①实例成员
在类定义中如果成员变量或成员方法没有用 static 来修饰，则该成员就是实例成员。
例如：主方法 main() 中分别用 new 运算符创建两个新的对象 volu1 和 volu2，这两个对象都各自拥有自己保存自己成员的存储空间，而不能与其他对象共享。如图：
实例方法：必须先创建对象，再利用对象来调用方法、，而无法不通过对象而直接去调用volume() 方法。
②静态变量：用 static 修饰的成员变量称为静态变量，也称为类变量。
格式：1）类名.静态变量名
2）对象名.静态变量名
注意：类中若含有静态变量，则静态变量必须独立于方法之外，就像其他高级语言在声明全局变量是必须在函数之外声明一样。
例子：将圆柱体类 Cylinder 里的变量 pi 和 num 声明为静态变量。
class Cylinder{ private static int num = 0;
private static double pi = 3.14;
private double radius;
private int height;
public Cyilinder(double r,int h){
radius = r;
heighet = h;
num++;
}
public void count(){
System.out.print("创建了"+ num +"个对象：")；
}
double area(){
return pi * radius * radius;
}
double voulume(){
return area()*height;
}
}
public class{
public static void main(String[] args){
Cylinder volu1 = new Cylinder(2.5,5);
volu1.count();
System.out.println("圆柱 1 的体积 = "+volu1.volume());
Cylinder volu2 = new Cylinder(1.0,2);
volu2.count();
System.out.println("圆柱 2 的体积 = "+volu2.volume());
}
}
创建了 1 个对象：圆柱 1 的体积 = 98.125
创建了 2 个对象：圆柱 2 的体积 = 6.28
5.静态方法
与静态变量相似，用 static 修饰符的方法属于类的静态方法，又称类方法。静态方法的实质是属于整个类的方法，而不加 static 修饰的方法
是属于某个具体对象的方法。将一个方法声明为 static 有以下几重含义。
（1）非 static 的方法是属于某个对象的方法，在创建这个对象时，对象的方法在内存中拥有属于自己专用的代码段。而 static 的方法是属于整个类的，
它在内存中的代码段将被所有的对象所公用，而不被任何一个对象所专用。
（2）由于 static 方法是属于整个类的，所以它不能直接操纵和处理属于某个对象的成员，而只能处理属于整个类的成员，即 static 方法只能访问 static 成员
变量或调用 static 成员方法，或者说在静态方法中不能直接访问实例变量与实例方法。静态方法中虽不能直接访问非静态成员，但可以通过创建对象的方法间接
地访问非静态成员。
（3）在静态方法中不能使用 this 或 super 。因为 this 是代表调用该方法的对象，但现在静态方法既然不需要对象来调用，this 也自然不应存在于静态方法内部。
（4）调用静态方法时，可以使用类名直接调用，也可以用某个具体对象名来调用。格式：类名.静态方法名(); 对象名.静态方法名();
例子：利用圆柱体类 Cylinder 来介绍静态方法的使用。
class Cylinder{ private static int num = 0;
private static double pi = 3.14;
private int height;
public Cylinder(double r,int h){
radius = r;
height = h;
num++; //当构造方法 Cylinder() 被调用时，num 便加 1
}
public static void count(){ //声明 count() 为静态方法
System.out.println("创建了"+ num +"个对象")；
}
double area(){
return pi * radius * radius;
}
double volume(){
return area() * height;
}
}
public class{
public static void main(String[] args){
Cylinder.count(); //在对象产生之前用类名 Cylinder 调用 count()方法
Cylinder volu1 = new Cylinder(2.5,3);
volu1.count(); //用对象 volu1 调用 count() 方法
Cylinder volu2 = new Cylinder(1.0,2);
volu2.count(); //用类名 Cylinder 直接调用 count() 方法
System.out.println("圆柱 2 的体积 ="+ volu2.volume())；
}
}
创建了 0 个对象
创建了 1 个对象
圆柱 1 的体积 = 58.875
创建了 2 个对象
圆柱 2 的体积 = 58.875
6.对象的应用
变量可分为基本类型的变量与非基本类型的变量两种。在声明基本类型的变量时采用的格式是“数据类型 变量名”，如 int a,double b 等。声明一个对象的格式
与其相似，即“类名 对象名”。因而也可以将对象称为类类型变量，它属于非基本类型变量。实际上对象是一种引用变量，而引用型变量实际上保存的是对象在内存中
的首地址（也称为对象的句柄），所以就对象的功能而言，对象是“指向对象的变量”，但就其类型而言它属于“类类型的变量”。因此在某些场合，可以像使用基本类型
一样使用对象。
①对象的赋值
（例如：张三和李四是同一个人，取了两个不同的名字）
class Cylinder{ private static double pi = 3.14;
private double radius;
private int height;
public Cylinder(double r,int h){
radius = r;
height = h;
}
public void setCylinder(double r,int h){
radius = r;
height = h;
}
double volume(){
return pi * radius * radius * height;
}
}
public class{
public static void main(String[] args){
Cylinder volu1,volu2; //声明 volu1，volu2 两个引用型变量
volu1 = new Cylinder(2.5,5); //创建对象，并将 volu1 指向它
System.out.println("圆柱 1 的体积 = "+volu1.volume());
volu2 = volu1; //将 volu2，volu2也指向该对象
volu2.setCylinder(1.0,2); //重新设置圆柱的底半径和高
System.out.println("圆柱 2 的体积 = "+volu1.volume());
}
}
圆柱 1 的体积 =98.125
圆柱 2 的体积 =6.28
7.JAVA语言的垃圾回收
在Java 程序的生命周期中，Java 运行环境提供了一个系统的垃圾回收器线程，负责自动回收那些没有被引用的对象所占内存，这种清除无用
对象进行内存回收的过程就叫做垃圾回收。垃圾回收是Java 语言提供的一种自动内存回收功能，可以让程序员减轻许多内存管理的负担，也减少程序员的犯错机会。
当一个对象被创建时，JVM会为该对象分配一定的内存，调用该对象的构造方法并开始跟踪该对象。当该对象停止使用时，JVM将通过垃圾回收器回收该对象所占用的内存。
系统中的任何对象都有一个引用计数器，一个对象被引用 1 次，则该对象的引用计数器为 1 ，被引用 2 次，则该对象的引用计数器为 2 ，以此类推，当一个对象的引用计数器减到 0 时，
说明该对象可以回收。
垃圾回收的好处：
（1）它把程序员从复杂的内存追踪、检测、释放等工作解放出来。
（2）它防止了系统内存被非法释放，从而使系统更加稳定。
垃圾回收的特点：
（1）只有当一个对象不被任何引用类型的变量使用时，它占用的内存才可能被垃圾回收器回收
（2）不能通过程序强迫回收器立即执行。
（3）当垃圾回收器将要释放无用对象占用的内存时，先调用该对象的 finalize() 方法。
posted on
2022-03-06 21:56
咕噜咕噜哈里
阅读(13)
评论(0)
编辑
收藏
举报
以上是 JAVA语言的特性 - 咕噜咕噜哈里 的全部内容， 来源链接： utcz.com/z/393555.html
