面向对象

最新推荐文章于 2024-07-08 09:19:38 发布

原创最新推荐文章于 2024-07-08 09:19:38 发布 · 418 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#面向对象

java学习专栏收录该内容

32 篇文章

订阅专栏

一、面向对象

面向对象的3个主要特性：封装性、继承性和多态性。

1.封装性

2.继承性

3.多态性

存在两种形式的多态：

①方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。

②对象多态：子类对象可以与父类对象进行相互的转换，而且根据其使用的子类的不同完成的功能也不同。

二、类与对象

2.1 类与对象的基本概念

类是抽象的，表述一类群体的基本特征；

对象是具体的事物，如张三的汽车；

如果要使用一个类，就一定有产生对象，每个对象之间是靠各个属性的不同来进行区分的，而每个对象所具备的操作就是类中规定好的方法。

2.2 类与对象的定义

==>类的定义格式。

class 类名称{

数据类型属性（变量）； //声明成员变量（属性）

···

}

public 返回值的数据类型方法名称（参数1，参数2···）{ //定义方法的内容

程序语句；

[return 表达式；]

}

==>对象的产生格式：

①声明并实例化对象： 类名称对象名称=new 类名称（）；

②分步完成：声明对象： 类名称对象名称=null;

实例化对象： 对象名称 = new 类名称（）；

==>类的操作

①对象.属性：表示调用类中的属性;

②对象.方法():表示调用类中的方法。

2.3 引用传递

核心：一块堆内存空间（保存对象的属性信息）可以同时被多个栈内存所共同指向，则每一个栈内存都可以修改同一块堆内存空间的属性值。

三、封装性

为何要封装？

为了保证类内部数据结构的完整性，使得用户不能轻易直接的操作此数据结构，提高程序的可维护性。

package com.test2;

public class Test1 {

	public static void main(String[] args) {
	//	Person per=new Person();
//		Person per1=null;
//		per1=new Person();
//		per1.name="刘亦菲";
//		per1.age=28;
//		per1.tell();
		//不封装的例子
//		Person per2=new Person();
//		per2.name="刘诗诗";
//		per2.age=26;
//		per2.tell();
		
		Person per=new Person();
		per.setName("刘亦菲");//使用我们封装好的setName
		per.setAge(30);//使用我们封装好的setAge
		per.tell();
	}

}
class Person{
	//使用private关键字将属性私有化，让用户看不见操作的东西。
	private String name;
	private int age;
	/*加入private关键字后，Person类的外部无法直接利用对象调用类中的属性，此时我们已经保证了属性安全，
	 * 我们需要仍然使用这些属性的话，就需要按照如下形式定义操作方法：
	 * 1.setter
	 * 2.getter
	 * 调用set,get方法
	 */
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>=0&&age<=250){
			this.age = age;
		}
		
	}
	
	public void tell(){
		System.out.println("姓名："+name+",  年龄："+age);
	}
}

四、构造方法

package com.test3;


public class Test1 {
	public static void main(String[] args) {
		
		Person per=new Person("刘亦菲",28);
		per.tell();
	}
}

	class Person {
		private String name;
		private int age;
//<==================================>		
		/*在Person类中，我们构造了以下的方法，参数是两个，如此我们在实例化Person类时，就必须通过构造方法传递指定的参数，
		 * 不再需要通过“对象.setter()”进行属性的设置
		 * 
		 */
	    public Person(String n,int a) {
			setName(n);
			setAge(a);
		}
//<==================================>		    
	    public void tell(){
			System.out.println("姓名："+name+",年龄："+age);
		}
		public void setName(String n) {
            name=n;
	}
       public void setAge(int a) {
			if(a>=0&&a<=250){
				age=a;
			}
		}
		
		public String getName() {
			return name;
		}
	
		public int getAge() {
			return age;
		}	
	}

构造方法可以进行重载，我们需要考虑参数的类型及个数，并且方法名称一定要和类名称保持一致。

类中定义属性的默认值，只有在构造执行完毕后，才可以真正赋值。

五、匿名对象

我们之前讲道：按照内存关系来讲，对象的名字可以解释为在栈内存中保存，而对象的具体内容（属性）在堆内存中保存，但若没有栈内存指向的堆内存空间，就是一个匿名对象。

范例：

package com.test4;

public class Test1 {

	public static void main(String[] args) {
		new Person("刘亦菲",28).tell();//匿名对象.方法()
	}

}

class Person{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}	
	public void tell(){
		System.out.println("姓名："+name+", 年纪："+age);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

使用匿名对象调用了类中的方法，但由于匿名对象没有对应的栈内存指向，所以只能使用一次，一次之后将成为垃圾，等待GC回收释放。