java学习---类

最新推荐文章于 2023-07-11 15:23:58 发布
最新推荐文章于 2023-07-11 15:23:58 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuzengqiang/article/details/8494852
版权

构造函数：在创建对象的同时，给对象的赋初值。
构造函数的函数名必须与类名同名.

如:

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   /**
    * 显示该圆的基本信息
    */
   
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
    
	public static void main(String args[])
    {
        CCircle c=new CCircle(); //创建一个属于CCircle类的一个对象
        //c.color="yellow"; 错误,由于color为私有类型,不能在类外赋值
        c.show();
    }
}

对象的创建: 类名 对象名 = new 类名();
如果不定义构造函数,那么java会自动调用默认构造函数,如上题:
public CCircle()
{

}
没有任何参数，所以上面的代码输出为:该圆的颜色: null,半径为: 0,面积为: 0.0

但是如果你提供了构造函数(无论是否构造函数中含有参数)，那么就不会提供默认的构造函数.
如在类外定义一个构造函数:CCircle(String Color,int Radius)

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   
   public CCircle(String Color,int Radius)
   {
	   color=Color;
	   radius=Radius;
   }
   
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   /**
    * 显示该圆的基本信息
    */
   
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
    
	public static void main(String args[])
    {
        CCircle c=new CCircle();
        //c.color="yellow"; 错误,由于color为私有类型,不能在类外赋值
        c.show();
    }
}

这个时候就会出现以下的编译错误:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor CCircle() is undefined. //找不到"没有参数的构造函数"

构造函数调用类中的另外一个构造函数，必须调用this,而不能以构造函数直接调用，否则会出现编译错误。
如：

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
   
   public CCircle(String Color,int Radius)
   {
	   color=Color;
	   radius=Radius;
   }
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   /**
    * 显示该圆的基本信息
    */
   
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
    
	public static void main(String args[])
    {
        CCircle c=new CCircle();
        //c.color="yellow"; 错误,由于color为私有类型,不能在类外赋值
        c.show();
    }
}

编译结果为:
该圆的颜色: red,半径为: 1,面积为: 3.1415
该圆的颜色: red,半径为: 1,面积为: 3.1415
第一行是调用构造函数输出的结果。

this的用法:
1、this([参数]);且只能放在构造函数的函数体的第一行，否则会出现编译错误。
2、this.成员变量; 表示对当前对象的引用.
如构造函数中变量名可以与成员变量同名,这个时候就要用this表示对当前对象的引用

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数
	   System.out.println("this: "+this);
   }
   
   public CCircle(String color,int radius)
   {
	   color=color;
	   radius=radius;
   }
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   /**
    * 显示该圆的基本信息
    */
   
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
    
	public static void main(String args[])
    {
        CCircle c=new CCircle();
        //c.color="yellow"; 错误,由于color为私有类型,不能在类外赋值
        c.show();
    }
}

不用this，出现的结果为：
this: CCircle@ecb281 //返回为对象分配的内存，用16进制表示
该圆的颜色: null,半径为: 0,面积为: 0.0

由于没有用this表示对当前对象的引用,调用构造函数Color(String color,int radius)时
color=color，就不知道哪个color赋给哪个color,所以系统就直接赋值为空。
但是用this表示对当前对象的引用后，如:

public Color(String color,int radius)
{
    this.color=color;
    this.radius=radius;
}

就表示将color赋值给当前对象的this.color。
编译后的结果可想而知为:
this: CCircle@ecb281
该圆的颜色: red,半径为: 1,面积为: 3.1415

前面的第一个代码实际上是省略了this来表示对当前对象的引用，因为并没有出现异常的赋值状况，所以说
在每一个成员变量的调用前加上this关键字后结果依然不变。
如：

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
    
   public double area()
   {
	   return (this.pi)*(this.radius)*(this.radius);
   }
  
   public void show()
   {
	   System.out.println("该圆的颜色: "+this.color+",半径为: "+this.radius+",面积为: "+this.area());
   }
}
public class method1 {
    
	public static void main(String args[])
    {
        CCircle c=new CCircle();
        c.show();
    }
}

3、this.成员方法，如上面的代码中this.area().
注意：this只能在当前类里面使用，不能在类外使用，且在static方法中不能使用。


当然构造函数也有公有和私有构造函数，含义和成员变量一样，私有构造函数只能在类里面进行调用，类外部不能被调用。

静态变量：被所有对象共享,只需在变量前加上static修饰符。
被static修饰的变量可以使得该类产生的对象共享同一个static变量。
被修饰的变量放在静态内存，且静态区内存里的数据可以共享。

如上面的代码中我想知道创建了多少个CCircle类的对象，就可以定义一个static的count变量，生成一个对象count+1，最后输出count值即可。

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   private static int count;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数,this必须放在构造函数的第一行!!
   }
   
   public CCircle(String color,int radius)
   {
	   this.color=color;
	   this.radius=radius;
	   count++;
	   System.out.println("创建了"+count+"个对象");
   }
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   /**
    * 显示该圆的基本信息
    */
   
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
    
	public static void main(String args[])
    {
        CCircle c1=new CCircle(); //直接调用第一个构造函数
        c1.show();
        CCircle c2=new CCircle("yellow",2); //调用第二个构造函数
        c2.show();
    }
}

输出的结果为：
创建了1个对象
该圆的颜色: red,半径为: 1,面积为: 3.1415
创建了2个对象
该圆的颜色: yellow,半径为: 2,面积为: 12.566

static的使用不能以任何方式引用this和super。
static变量在类加载的时候，对象创建之前就已经被初始化.但是对象是在创建时才在内存中生成的。
而在方法中定义使用的this关键字指的就是对当前对象的引用.所以在static中使用this的话,this就无法指向合适的对象.

static和非static的区别:
1>static定义的函数，外部程序可以直接调用通过类名.函数名([参数])调用，但非static方法则必须通过创建对象后通过对象名.函数名([参数])的方法调用.

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   private static int count;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数,this必须放在构造函数的第一行!!
   }
   
   public CCircle(String color,int radius)
   {
	   this.color=color;
	   this.radius=radius;
	   count++;
	   System.out.println("创建了"+count+"个对象");
   }
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   public static void perimeter() 
   {
	   System.out.println("圆");
   }
   /**
    * 显示该圆的基本信息
    */
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
    public static void main(String args[])
    {
        CCircle c1=new CCircle();
        c1.show(); //非static通过类名.函数名的方法调用
        CCircle c2=new CCircle("yellow",2);
        c2.show();
        CCircle.perimeter();//static定义的方法可以直接用类名.函数名的方法调用
    }
}


2>类的内部,static的方法不能调用非static的方法，但是非static的方法可以调用static的方法.
上例中若是将perimeter()中的内容改成:

public static void perimeter()
{     System.out.println("圆");
       System.out.println("该圆的面积为: "+area());
}

就会出现编译错误:
Cannot make a static reference to the non-static method area() from the type CCircle.
无法在静态方法中调用非静态方法area()。
上例中调用area()就相当于调用this.area(),而static中不能以任何方式调用this。所以不能调用非static的方法

3>static方法不能使用成员变量(同理,调用成员变量=this.成员变量,但static中不能含this).而非static方法中可以调用static 的变量.因为static的变量是在可以类中共享的。
同样将perimeter中的内容改成:

public static void perimeter()
{     System.out.println("圆");
       System.out.println("该圆的颜色为: "+color);
 }

也会出现编译错误。

如果一个类中没有定义成员变量,那么尽量将该方法定义为static方法。

对于main()它也是类method1(文件名)的一个函数,调用mian()的是类method1,而不是method1所创建的对象.因为main()是一个java程序的入口程序,所以在jvm调用
main()的时候希望能够直接调用main(),而不是再创建一个新的对象来调用main(),所以main的修饰符为static,这样jvm就能直接调用main()。

因此，在文件名所创建的类定义的成员变量最好使用static。这个时候就可以在main中直接调用。

import java.util.Scanner;

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   private static int count;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数,this必须放在构造函数的第一行!!
   }
   
   public CCircle(String color,int radius)
   {
	   this.color=color;
	   this.radius=radius;
	   count++;
	   System.out.println("创建了"+count+"个对象");
   }
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   public static void perimeter()
   {
	   System.out.println("圆");
   }
   /**
    * 显示该圆的基本信息
    */
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
	
    static Scanner  input=new Scanner(System.in);
	public static void main(String args[])
    {
        CCircle c1=new CCircle();
        c1.show();
        CCircle c2=new CCircle("yellow",2);
        c2.show();
        CCircle.perimeter();
        
        String s=input.next();
        int r=input.nextInt();
        CCircle c3=new CCircle(s,r);
        c3.show();
    }
}

运行结果为：

创建了1个对象
该圆的颜色: red,半径为: 1,面积为: 3.1415
创建了2个对象
该圆的颜色: yellow,半径为: 2,面积为: 12.566
圆
blue 3
创建了3个对象
该圆的颜色: blue,半径为: 3,面积为: 28.2735

当然不定义static也行，直接在main中创建一个新的对象再调用即可。

import java.util.Scanner;

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   private static int count;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数,this必须放在构造函数的第一行!!
   }
   
   public CCircle(String color,int radius)
   {
	   this.color=color;
	   this.radius=radius;
	   count++;
	   System.out.println("创建了"+count+"个对象");
   }
   
   /**
    * 求该圆的面积
    */
   public double area()
   {
	   return pi*radius*radius;
   }
   
   public static void perimeter()
   {
	   System.out.println("圆");
   }
   /**
    * 显示该圆的基本信息
    */
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
	
    Scanner  input=new Scanner(System.in);
	public static void main(String args[])
    {
        CCircle c1=new CCircle();
        c1.show();
        CCircle c2=new CCircle("yellow",2);
        c2.show();
        CCircle.perimeter();
        
        method1 m=new method1();
        String s=m.input.next();
        int r=m.input.nextInt();
        CCircle c3=new CCircle(s,r);
        c3.show();
    }
}

在static方法中可以通过创建一个新的对象来调用非static成员变量及方法。但貌似没这个必要。。
static变量尽量不要在构造函数中进行初始化，不然每次创建一个新的对象static的值又会被初始化。

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   private static int count;
    
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数,this必须放在构造函数的第一行!!
       count=0;
   }
   
   public CCircle(String color,int radius)
   {
	   this.color=color;
	   this.radius=radius;
	   count++;
	   System.out.println("创建了"+count+"个对象");
   }
   
   public double area()
   {
	   return pi*radius*radius;
   }
      
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
	
	public static void main(String args[])
    {
        CCircle c1=new CCircle();
        c1.show();
        CCircle c2=new CCircle();
        c2.show();
    }
}

编译运行后结果为：

创建了1个对象
该圆的颜色: red,半径为: 1,面积为: 3.1415
创建了1个对象
该圆的颜色: red,半径为: 1,面积为: 3.1415

static初始化:

1>可以直接在定义时赋值;
2>当变量较多时,可以放在static静态代码块中进行初始化.

class CCircle{
   private String color; //将颜色定义为私有类型的成员变量,表示在类的外部不能改变其值
   private double pi=3.1415;
   private int radius;
   private static int count;
    
   static{
	   count=0;
   }
   
   public CCircle()
   {
	   this("red",1); //调用下面的构造函数,this必须放在构造函数的第一行!!
   }
   
   public CCircle(String color,int radius)
   {
	   this.color=color;
	   this.radius=radius;
	   count++;
	   System.out.println("创建了"+count+"个对象");
   }
   
   public double area()
   {
	   return pi*radius*radius;
   }
   
   public void show()
   {
	   System.out.println("该圆的颜色: "+color+",半径为: "+radius+",面积为: "+area());
   }
}
public class method1 {
	
	public static void main(String args[])
    {
        CCircle c1=new CCircle();
        c1.show();
        CCircle c2=new CCircle();
        c2.show();
    }
}


 

 

xuzengqiang
关注
专栏目录
C++定义对象：Circle类
miaaozhu2015的专栏
03-26 1万+
【3.22 】声明一个Circle类，有数据成员radius（半径）、成员函数area（），计算圆的面积，构造一个Circle的对象进行测试。 #include #include using namespace std; class Circle{       //声明圆类 double r;       //定义圆的半径r double cs;      //定义圆的面积cs
java8源码-java-learning-copy:java-学习-复制
06-04
构建，分模块学习，涉及反射，代理，多线程，IO，集合类等核心知识。 如果觉得不错，请先在这个仓库上点个 star 吧，这也是对我的肯定和鼓励，谢谢了。 不定时进行调整和补充，需要关注更新的请 watch、star、fork ...
习题：设计一个圆Circle类，包含圆心和半径两个数据成员。①编写合理的构造方法。
最新发布
weixin_56463218的博客
07-11 1262
③编写计算圆是否包含指定的点contains（Point），contains（int x，int y）。设计一个圆Circle类，包含圆心和半径两个数据成员。②编写计算圆面积的方法getArea（）。①编写合理的构造方法。
The constructor Vibrator() is not visible
weixin_34293246的博客
04-13 866
引用：http://www.eoeandroid.com/forum.php?mod=viewthread&tid=8546 mVibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
PTA:7-17 Circle类 (10 分)
weixin_47942875的博客
05-30 3631
题目描述： a： 定义圆类Circle，其中包括： 成员变量定义 private int radius 方法定义 包括下列要求 定义无参构造方法 ，给radius赋值为2，并添加语句System.out.println(“this is a constructor”); 定义有参构造方法 ，接收用户给给radius赋值，如果用户输入半径为<=0,则让半径的值为2，并添加语句System.out.println(“this is a constructor with para”); 为radius半径添
java反编译class源码-java-n-IDE-for-Android:java-n-IDE-for-Android
06-05
这个项目是为了帮助社区在android上学习java而开发的。 您可以使用 JDK 1.7 构建和运行 Java 文件。 在 Google Play 商店下载 去做 Java 编译器 JDK 1.7 :check_mark: Java编辑器 :check_mark: Java自动完成代码 :...
java基础教程----精华版
09-22
Java是一种广泛使用的面向对象的编程语言，以其平台独立性、安全性、健壮...这份"java基础教程----精华版"应该涵盖了这些主题，并且可能还有更多的实践指导和示例代码，对于学习和巩固Java编程基础是非常有价值的资源。
java代码-java字符串工具类源代码合集
04-09
java代码-java字符串工具类源代码合集 ——学习参考资料：仅用于个人学习使用！
java-a-course-for-beginners:初学者Java编程教程
03-28
250个步骤学习Java编程 动手逐步介绍最流行的编程语言 入门 Eclipse- Maven- JUnit- 安装工具 PDF： : 概述 介绍 我们喜欢编程。 本课程的目的是为了热爱编程。 Java是最流行的编程语言之一。 Java提供了面向...
Java（3）对象和类
Yan__Ran的博客
04-15 1099
一、为对象定义类 我将对象与类之间的关系总结为了以下这张图： 总而言之，类（class）是一个模板，而对象（object） 是一个实体，可以理解为对象是类的具象化体现。并且一个模板可以产生多个实体，也就是说可以从一个类中创建多个对象。 同时类还提供了一种特殊类型方法：构造方法 ...
定义一个circle类，有数据成员radius（半径），成员函数getarea（）， 计算圆的面积，构造一个Circle的对象进行测试
热门推荐
qq_48474606的博客
11-26 2万+
具体代码如下： #include <iostream> using namespace std; class circle{ //定义一个circle类； public: circle(double radius){ r=radius; } ~circle(){}; //析构函数； double getarea(){return 3.14*r*r;} //此处Π取3.14； private: double r; }; void main(){ //主函数； cou
The constructor Date() is undefined
unique_cn的博客
08-01 3264
import java.sql.Date; public class Zuoy1 {     public static void main(String[] args) {                  Date date = new Date();//错误The constructor Date() is undefined         long l = date.getTime()...
The constructor StringBuilder(String) is undefined 解决方法
weixin_45866907的博客
05-03 4937
The constructor StringBuilder(String) is undefined 解决方法
Date型转为String型
ddxxll2008的专栏
04-18 687
今天改一个程序，需要把一个Date型的字段转为String型的，代码如下：DateFormat format = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”); Date date = new Date(); //错误提示The constructor Date() is undefined String endTimee = for
The constructor Date() is undefined （java引用date()报错的问题）
兔老大的胡萝卜
12-03 3045
解决办法：看看自己引用的包是不是import java.util.Date;默认的是import java.sql.Date;
C++--类与对象（三）
qq_46659987的博客
03-11 687
文章目录1. 构造函数（扩充）（1）构造函数体赋值（2）初始化列表（3）explicit关键字2. static3.友元 1. 构造函数（扩充） （1）构造函数体赋值 （2）初始化列表 （3）explicit关键字 2. static 3.友元
Java 自定义类里面的对象自动赋初值
manmantj的博客
06-16 6869
在Java程序开发中，在自定义自己的类的时候，如果这个类的成员变量是基本的数据类型，就算声明的时候没有进行初始化，系统也会自动给其初始化一个值，但是方法里面的局部变量则必须要声明一个初值，否则无法通过编译（eclipse中）：public class Test1 { public static void main(String[] args) { DataTest data =
C#基础知识及题目练习 Day9 面向对象 类
Aurora_m的博客
08-05 608
一、面向过程与面向对象 1.面向过程：注重完成这件事的过程，做这件事儿经过了哪几个步骤 好处：符合人们的逻辑思维 坏处：一件事儿需要为不同的人来量身定做 2.面相对象：旨在写一个通用的方法，屏蔽不同对象之间的差异 在程序中描述一个对象，通过描述它的特点和行为来操作这个对象 在程序当中，特点叫属性，行为叫方法 所以说，在程序中描述一个对象是通过描述他的属性和方法来操作它的 3.类：类是一个模...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值