JAVA中面向对象的核心概念——类
对象：是有一定结构的，这个结构是由属性与行为所组合的一个单元，对象通过属性来表现其所有的特性而呈现其状态，并通过行为方式来表现其能力，其中属性与方法合称为该对象的特征。
1．声明和定义类
a) point 类
class Point
{
int x;
int y;
public void setCoordinate(int x,int y){
this.x=x;
this.y=y;
System.out.println("新的坐标点(x,y)是("+x+","+y+")");
}
};
b) Circle类
import java.lang.Math;
class Circle //类的声明
{
double radius;
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
类的定义声明的时候都不会造成任何内存的设置，只有当程序定义出类的对象时，内存空间才会被设置出来。
2．建立一个对象
a) 就是我们经常说的NEW一个对象出来
（1） 声明一个标识符来作为对象的名称，并且使用类名称作为该标识符的数据类型。
（2） 在加上一个 NEW 运算符号所构成的表达式
（3） 在设置一个初始状态，可以通过构造函数来设置。创建对象时必须选择适当的构造函数来与NEW运算符号搭配。
import java.lang.Math;
class Circle //类的声明
{
double radius;
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
Circle acircle=new Circle();//建立一个对象
}
}
3．对象名称的意义
a) 状况1。使用”=”进行赋值运算
赋值运算的原本意是将数据放到内存中.是将右边的数据放到左边的数据名称.左边的数据名称就好象是一个容器..
在对于对象来说,对象名称代表的是某一个实际存在的对象的地址.所以在对象来说,他的意义就是将右边对象对峙放到”=”左边的对象名称里面,其实没有产生新的对象.
import java.lang.Math;
class Circle //类的声明
{
double radius;
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
Circle acircle=new Circle();
acircle.setRadius(12.0);
Circle bcircle;
bcircle=acircle;//和acircle对应了同样的对象.
acircle.showRadius();
bcircle.showRadius();
bcircle=null;
acircle.showRadius();
}
}
b) 状况2。使用”==”进行相等运算
import java.lang.Math;
class Circle //类的声明
{
double radius;
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
Circle acircle=new Circle();
Circle bcircle=new Circle();
acircle.setRadius(12.0);
bcircle.setRadius(12.0);
if(acircle==bcircle) //使用”==”进行相等运算
System.out.println("acircle 与 bcircle 是两个相同的对象");
else
System.out.println("acircle 与 bcircle 是两个不同的对象");
int a=5;
int b=5;
if(a==b)
System.out.println("a 与 b内容相等");
else
System.out.println("a 与 b内容不相等");
}
}
c) 状况3. null value
import java.lang.Math;
class Circle //类的声明
{
double radius;
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
Circle acircle=new Circle();
acircle.setRadius(12.0);
Circle bcircle;
bcircle=acircle;//和acircle对应了同样的对象.
acircle.showRadius();
bcircle.showRadius();
acircle=null;
bcircle.showRadius();
}
}
d) 状况4. 使用final来设置数据名称的行为时
import java.lang.Math;
class Circle //类的声明
{
double radius;
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
final Circle acircle=new Circle();
acircle.setRadius(12.0);
acircle.showRadius();//这么是对象设置是可以的
acircle =new Circle();//无法为最终变量 acircle 指定值不能重新设定新的参考
final int c=10;
// c=12; //注意这样操作会出错 final 类型 =右边不能赋值.
}
}
4．存取权修饰符
a) private
b) default(friendly友元)不写默认
c) protected
d) public
在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。
1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。
作用域当前类同一package 子孙类其他package
public √√√√
protected √√√×
friendly √√××
private √×××
不写时默认为friendly default(friendly友元)不写默认
5．this 的意义
代表是当前这个类.
6．构造函数的意义
和类同样名称的一个特殊的方法(一般不能称为方法) 通过NEW 创建时所用
import java.lang.Math;
class Circle //类的声明
{
double radius;
Circle()//这个就是一个构造函数
{
this.radius=18.0;
}
void setRadius(double xRadius)
{
this.radius=xRadius;
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
Circle acircle=new Circle();
acircle.showRadius();
}
}
结果:
E:\>java MyApplication
半径为：18.0
7．对象的身份
我们提到的每一个对象对与生俱来有一个用来识别身份的独一无二的对象的身份(identity),而这个对象的身份是通过hashCode()方法而来
import java.lang.Math;
class Circle //类的声明
{
double radius;
Circle()
{
this.radius=18.0;
}
public void showIndentity()
{
System.out.println("目前对象的身份是"+hashCode());
}
void showRadius(){
System.out.println("半径为："+radius);
return;
}
/*返回 pi*r平方
*/
double showArea(){//PI :double 值比任何其他值更接近圆的周长与直径之比 pi
return Math.PI*Math.pow(radius,2);//Math.pwd返回第一个参数的第二个参数次幂的值
}
}
public class MyApplication
{
public static void main(String[] args)
{
Circle acircle=new Circle();
acircle.showRadius();
acircle.showIndentity();
Circle bcircle;
bcircle=acircle;
bcircle.showIndentity();
bcircle=new Circle();
bcircle.showIndentity();
}
}
运行结果:
E:\>java MyApplication
半径为：18.0
目前对象的身份是7699183
目前对象的身份是7699183
目前对象的身份是14285251
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
