Java教程

Java的对象和类

本文主要是介绍Java的对象和类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1.Java 对象和类

类:它是抽象出一类事物的行为和状态。类是一个模板,用于创建具体实例(对象)的数据类型,类所声明的变量称作对象
对象:对象是类的一个实例,对象的状态就是属性,行为通过方法体现

1. 类的定义:包括类的声明和类体的内容

  1. 类的声明:用到class关键字,class 类名{类体的内容} 类名首字母要大写,要见名知意
  2. 类体的内容:包含 变量的声明和方法的定义
    (1)变量的声明:称作成员变量 在整个类中都有效
    (2)方法的定义:类比于C语言中的函数的定义:
    方法头:方法的类型 名称 (形参列表)
    方法体中声明的变量和形参,称作是局部变量

2. 构造方法:

在创建对象时,用来初识化该类中的对象

  1. 构造方法的名字必须和它所在的类的名字完全相同
  2. 构造方法没有类型(返回类型)
  3. 允许在一个类中编写若干个构造方法,但他们的参数不同
    (1)参数的个数不同 (2)个数同,但参数列表中对应的某个参数类型不同
    又分为无参和有参的构造方法,一般都写
  4. 若类中没有写构造方法,系统默认该类只有一个构造方法:无参数,方法体中无语句;但若类中定义了一个或多个构造方法,就不提供默认的构造方法

3. 创建对象

包括:

(1)对象的声明: 类名 对象名;

(2)为声明的变量来分配变量:使用new运算符和类的构造方法

解释:内存模型:

public class Xi {//定义一个Xi类
	float h;
	String w;
	void speak(String s) {//方法
		System.out.println(s);
	}
	public static void main(String[] args) {
		Xi dx = new Xi(); 
	}
}
  1. 执行new Xi();时,会为该Xi类中的成员变量h 和w分配内存空间
  2. 执行构造方法中的语句;此时没有构造方法,系统提供默认的构造方法:
    Xi(){}
    若成员变量在声明的时候没有赋初值,在构造方法中也没有赋初值;那他会有默认值:整型:0 浮点型:0.0 布尔型:false 引用型:null

new 运算符在为成员变量分配内存后,将计算出一个称为引用的值(包含了这些成员变量的内存位置和相关的信息)就是指new Xi()是一个十六进制的数值
4. dx = new Xi(); 执行赋值语句,将引用给了对象dx,对象就可以操作管理这些变量
new 运算符只和类的构造方法进行计算得出一个引用,再赋值给对象,则对象就拥有了被new 运算符分配了内存的成员变量

4. 访问对象的变量和方法

1. 成员变量又可以分为实例变量和类变量(静态变量)

  1. 类变量就是在变量的类型前面加上static 例如:static int a;
  2. 此类不同的对象的实例对象不相同,占用不同的内存空间
  3. 此类所有对象共享类变量,占用相同的内存空间,改其中一个对象的类变量,其他对象的类变量也随着改变
  4. 通过 对象. 来访问实例变量
  5. 通过 类名. 来访问类变量

2.除构造方法外,方法又分为实例方法和类方法(静态方法)

  1. 通过 对象. 来调用实例方法
    因为只有该类创建对象后,类中的实例方法才分配入口
  2. 通过 类名. 来调用类方法
    因为该类被加载到内存,类中的类方法就分配了入口
public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数:name
      System.out.println("小狗的名字是 : " + name ); 
   }
 
   public void setAge( int age ){
       puppyAge = age;
   }
   
   public int getAge( ){
       System.out.println("小狗的年龄为 : " + puppyAge ); 
       return puppyAge;
   }
   
   public static void main(String[] args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPuppy.puppyAge ); 
   }
   //小狗的名字是 : tommy
    小狗的年龄为 : 2
    变量值 : 2

5. 访问修饰符

定义:用来表示对象是否可以通过 . 点运算符来操作自己的变量和用类中的方法

1.私有变量和私有方法(常用)

指的是:用关键字private来修饰的变量和方法
当在另一个类中创建了该类的对象后,对象不可以访问自己的私有变量和调用自己的私有方法(也不可以用类名去访问私有的类变量和私有类方法)

2. 共有变量和共有方法(常用)

指的是:用关键字pulic来修饰的变量和方法
在任何一个类中创建了该类的对象后,对象都可以访问自己的共有变量和调用自己的共有方法

3. 受保护的变量和方法

指的是:用关键字protected来修饰的变量和方法
当在另一个类中创建了该类的对象后,当两个类在同一个包中,对象可以访问自己的protected变量和方法

4.友好变量和友好方法

指的是:没有用关键字来修饰的变量和方法,当在另一个类中创建了该类的对象后,当两个类在同一个包中,对象可以访问自己的友好变量和方法

5.pulic类和友好类

不可以用protected和private来修饰类

  1. 在类声明时,在class前加上pulic,得到一个pulic类,就可以在任何一个类中使用public类来创建对象
  2. 不用public修饰的类称作友好类,在另一个类中使用该友好类创建对象时,要保证他们在同一个包中

6.关于实例和静态的总结

1.关于实例和静态:

package review;

public class review1 {
	public void m1() {}
	public void m2() {}
	public static void m3() {}
	public static void m4() {}
	public static void main(String[] args) {
		 //m1();
		 //m2();
		 m3();
		 m4(); 
		/*发现m1,m2不可以,m3,m4可以
		 * 分析:
		 * 1.main方法是静态的,java虚拟机JVM调用main方法时,直接采用“类名.”,所以静态方法中没有this;
		 * 2.m1(),m2()方法是实例方法,要通过“引用.”的方式去访问
		 * 3.m3(),m4()编译器会自动识别他们是静态方法,结果是“类名.m3()”
		 * 4.若想访问m1,m2方法,必须先创建对象*/
		  review1 a=new review1();
		  a.m1();
		  a.m2();
	}
	public void m5() {
		m1();
		m2();
		m3();
		m4();
	}
/*分析:
 * m5()是实例方法,执行这个方法的过程中,当前对象是存在的;
 *检测到m1(),m2()是实例方法,会在方法前自动加上“this.”
 *检测到m3(),m4()是静态方法,会在方法前自动加上“类名.”
 *以上的前提是,方法在同一类中
 * */
	int a=100;
	static int b=20;
	public void m6() {
		int c=1;
		 System.out.println(a);//系统自动识别为"this.a"
		 System.out.println(b);//识别为"review1(类名).b"
		 System.out.println(c);//局部变量访问时不需要"xxx."的,在方法体内定义的局部变量,直接访问即可
	}
	public  static void m7() {
		int c=1;
		review1 s=new review1();
		System.out.println(s.a);
		// System.out.println(a);静态中没有this,必须先创建对象
		 System.out.println(b);//识别为"review1(类名).b"
		 System.out.println(c);
	}
	
	/*以下是在不同类中,调用另一个类中的方法时,想调用T类中的t1()和t2()方法时,
	 * 可以直接t1();t2();吗?
	 * 
	*/
	public  static void m8() {
		T.t1();//在静态方法中访问另一个类中的静态方法,用类名.
		T a=new T();
		a.t2();//在静态方法中访问另一个类中的实例方法
		
	}
     public void m9() {
    	 T.t1();//在实例方法中访问另一个类中的静态方法,用类名.
		T a=new T();
		a.t2();//在实例方法中访问另一个类中的实例方法
	}
}


//以下是在不同类中,调用另一个类中的方法时
class T{
	public static void t1() {
	}
	public void t2() {	
	}
}
固定规律:所有的实例相关的都是先创建对象,通过“ 引用. ”来访问,所有静态相关的通过”类名 .“来访问
1.负责调用的方法a和被调用的方法b在同一个类中,才会出现"类名."和"this."可以省略的
2.若跨类调用,不论a是静态或者实例,b中的静态要"类名." 实例要先用b类创建对象,再用“对象.”去调用

7.包 package

  1. 不同的Java源文件中两个类名字相同时,就可以让他们隶属于不同的包来区分
  2. 使用关键字package来声明包语句:package 包名;
  3. 作为源文件的第一条语句,指定义的类所在的包
  4. 若没有package语句,称为无名包,在Eclipse中称作default package;

8. import语句

  1. 若一个类想使用的类不和它在同一个包中,就会用到import语句
  2. 一个Java源程序中可以有很多个import语句,它们必须写在package语句和源文件的类的定义之间
  3. 想使用类库中已存在的类直接引入用,但像java.lang包中的类直接使用,不需要引入,例如System类,Math类
这篇关于Java的对象和类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!