面向对象基础(类与对象的定义、进一步研究、封装性、构造方法与匿名对象)

 1、什么是面向对象：

万物皆对象，面向对象是一种更加优秀的程序设计方法，它的基本思想是使用类、对象、继承、封装、消息等概念来进行程序的设计。是从世界客观存在的事物(即对象)出发，并根据这些事物的本质特点，把它们抽象的表示为系统中的类，这样程序可以直接映射客观世界，并保持客观世界中事物及其相关关系的本来面貌。

2、面向对象的基本特征：

具有三个最基本的特征：封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism)。封装是将对象的实现细节隐藏起来，然后通过一些公用的方法来暴露该对象的功能；继承是指，当子类继承父类后，子类可以直接获得父类的属性和方法；多态指的是子类对对象可以直接赋给父类变量，但运行是依然表现子类的行为特征，这意味着同一个类型的对象在运行时可能表现不同的行为特征。

3、使用面向对象的好处：

可以为程序提供更好的可重用性、可扩展性和可维护性。

定义类和对象

类的定义：

class Person	//定义一个表示人的类
{
	//人有名字和年龄两个属性
	String name;
	int age;
	public void say(){		//人有说话的方法
		System.out.println("我的姓名是："+name+"年龄是"+age);
	}
}

产生对象，获得类中的属性或者方法，类的实际意义只是表示世界中客观存在的事物，当要获得属性及方法的时候要有一个实例，java中使用new关键字来创建该实例

class Person	//定义一个表示人的类
{
	//人有名字和年龄两个属性
	String name="张三";
	int age=20;
	public void say(){		//人有说话的方法
		System.out.println("我的姓名是："+name+"年龄是"+age);
	}
}
public class classDemo01{
	public static void main(String args[]){
		Person person=new Person();   //获得该类的实例
		person.say();     调用该对象中存在的方法
	}
}

类与对象的进一步研究

内存划分：对象的创建之初

代码如下：

public class classDemo01{

       public static void main(String args[]){

              Person person=new Person();

              person.say();

       }

}

内存效果图如下：

Person per=new Person();

·声明对象：Person per，在栈内存中声明，与数组一样，数组名称就是保存在栈内存中的，只开辟了栈内存的对象是无法使用的，必须有其堆内存的引用才可以使用。

·实例化对象：new Person(); 在堆中开辟空间，所有的内容都有默认值。

|-String：是一个字符串，其本身是一个类，就是一个引用数据类型，此时默认值为null，其值是不能改变的，若想改变它的值，只能是在栈内存中新声明一个对象

|-int：是一个整数，本身是一个数，所以是基本数据类型，此时的默认值为0

注意：所谓的引用数据类型，实际上就是堆内存的使用权，可以同时为一个堆内存空间定义多个栈内存的引用操作

封装性

封装就是保护内容，保证类的某些属性或者是方法不被外部看见。

封装的实现：

·为属性封装：private 属性类型 属性名称

·为方法封装：private 方法返回值 方法名称(参数列表){};

class Person{
	private String name ;			// 声明姓名属性
	private int age ;				// 声明年龄属性
	public void tell(){
		System.out.println("姓名：" + name + "，年龄：" + age) ;
	}
};
public class EncDemo02{
	public static void main(String arsgh[]){
		Person per = new Person() ;	// 声明并实例化对象
		per.name = "张三" ;			// 为name属性赋值
		per.age = -30 ;				// 为age属性赋值
		per.tell() ;
	}
};

以上代码运行起来会有错误，原因是因为Perosn类中name和age属性是私有的，只能在内部进行访问，外部是不可见的，那么怎么访问呢？

访问封装的内容：

因为类中的属性肯定表示的是一定的实际意义，那么这些意义的内容应该由外部设定，所以在整个java中对于封装性的访问就给出了一个明确的规则，此原则必须遵守。

被封装的属性如果需要被访问，则要编写set和get方法来完成。

在类的内部加入如下操作：

public void setName(String n){	// 设置姓名
		name = n ;
	}
	public void setAge(int a){		// 设置年龄
		if(a>=0&&a<=150){			// 加入验证
			age = a ;
		}
	}
	public String getName(){		// 取得姓名
		return name ;
	}
	public int getAge(){			// 取得年龄
		return age ;
	}

类的外部访问私有属性或者是方法时：

public class EncDemo05{
	public static void main(String arsgh[]){
		Person per = new Person() ;	// 声明并实例化对象
		per.setName("张三") ;		// 调用setter设置姓名
		per.setAge(-30) ;			// 调用setter设置年龄
		per.tell() ;				// 输出信息
	}
};

开发中一个实体类都是要写set和get方法的。

构造方法与匿名对象

构造方法

只要一有对象实例化就会调用构造方法。

构造方法的定义格式：

class 类名称{
	访问权限 类名称(类型1 参数1,类型2 参数2,...){
		程序语句；
			...//构造方法没有返回值
	}
}

注意事项：

·构造方法的名称必须与类名称一致

·构造方法的声明处不能有任何的返回值类型的声明

·不能在构造方法中使用return一个值

在整个java的操作中，如果一个类没有明确的声明一个构造方法，则会自动生成一个无参的什么都不做的构造方法。类似于以下形式：

class Person
{
	public Person(){};	//如果没有编写构造方法，则会自动生成此代码
}

构造方法的主要目的是为类中的属性初始化值。既然是方法，则方法中肯定可以传递参数，此时定义一个构造方法，并传递参数

class Person{
	private String name ;
	private int age ;
	public Person(String n,int a){		// 声明构造方法，为类中的属性初始化
		this.setName(n) ;
		this.setAge(a) ;
	}
	public void setName(String n){
		name = n ;
	}
	public void setAge(int a){
		if(a>0&&a<150){
			age = a ;
		}
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
	public void tell(){
		System.out.println("姓名：" + this.getName() + "；年龄：" + this.getAge()) ;
	}
};
public class ConsDemo02{
	public static void main(String args[]){
		System.out.println("声明对象：Person per = null ;") ;
		Person per = null ;	// 声明对象时并不去调用构造方法
		System.out.println("实例化对象：per = new Person() ;") ;
		per = new Person("张三",30) ;//实例化对象
		per.tell() ;
	}
};

注意：如果在类中有编写构造方法，并且有相应的参数，这时无参的构造方法并不会自动创建，如需使用，必须编写代码进行创建。

·构造方法的重载

构造方法的重载与普通方法一样，都是支持重载操作的，只要参数的类型或个数不同，就可以完成构造方法的重载。

class Person{
	private String name ;
	private int age ;
	public Person(){}					// 声明一个无参的构造方法
	public Person(String n){			// 声明有一个参数的构造方法
		this.setName(n) ;
	}
	public Person(String n,int a){		// 声明构造方法，为类中的属性初始化
		this.setName(n) ;
		this.setAge(a) ;
	}
	public void setName(String n){
		name = n ;
	}
	public void setAge(int a){
		if(a>0&&a<150){
			age = a ;
		}
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
	public void tell(){
		System.out.println("姓名：" + this.getName() + "；年龄：" + this.getAge()) ;
	}
};
public class ConsDemo03{
	public static void main(String args[]){
		System.out.println("声明对象：Person per = null ;") ;
		Person per = null ;	// 声明对象时并不去调用构造方法
		System.out.println("实例化对象：per = new Person() ;") ;
		per = new Person("张三",30) ;//实例化对象
		per.tell() ;
	}
};

匿名对象

匿名：没有名字，在java中如果一个对象只使用一次，则就可以将其定义为匿名对象。

class Person{
	private String name ;
	private int age ;
	public Person(String n,int a){		// 声明构造方法，为类中的属性初始化
		this.setName(n) ;
		this.setAge(a) ;
	}
	public void setName(String n){
		name = n ;
	}
	public void setAge(int a){
		if(a>0&&a<150){
			age = a ;
		}
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
	public void tell(){
		System.out.println("姓名：" + this.getName() + "；年龄：" + this.getAge()) ;
	}
};
public class NonameDemo01{
	public static void main(String args[]){
		new Person("张三",30).tell() ;
	}
};

红体字表示的就是一个简单的匿名对象，其实匿名对象就是比之前的对象少了一个栈内存的引用关系，它只开辟了堆内存的实例对象。

三目运算符

三目运算符 : 变量=条件判断?表达式1：表达式2;

解释：如果条件成立则将执行表达式1的内容 反之执行表达式2的内容

范例：

ublic static void main(String []args) {
	int max = 0;
	int x = 2 ;
	int y = 10 ;
	max = x > y ? x : y;
	System.out.println(max) ;
}

程序运行结果为10;

好处：代替了很长的if….else语句