面向对象概述

首先，什么是面向对象？

面向对象就是相对于面向过程来讲的，指的是把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，从而更贴近事物的自然运行模式。 面向过程到面向对象思想层面的转变：         面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。         面向过程到面向对象，是程序员思想上 从执行者到指挥者的转变。

举个例子：

问：         把大象装进冰箱 ， 需要分几步？ 回答：       面向过程回答：                 3步：1 把冰箱门打开， 2 把大象装进去 ， 3 把冰箱门关闭       面向对象回答：                 2步：1 招一个能操作冰箱的工人（对象）， 2 指挥工人装大象 思考：         如果问题改成： 把100 只大象依次关进冰箱，共分为几步？ 面向过程的回答： 此处需要省略 N 字。。。 面向对象的回答还是 2 步： 1 招一个能操作冰箱的工人（对象） ， 2 指挥工人把大象依次装进去。 所以简单来说，面向过程就是一步一步来，面向对象就是把重复化的东西写成总方法，在用一个对象去调用这种方法的过程。

类与对象的关系

两者的关系

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。 （类似生活中的图纸与实物的概念。） 类必须通过对象才可以使用，对象的所有操作都在类中定义。 类由属性和方法组成：         属性：就相当于人的一个个的特征  {String，int，double。。。。。}         方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉  （void say（）{。。。}）

类与对象的创建

类的定义格式

class 类名称 {         成员属性         成员方法         }

其中属性和方法

属性定义格式：         数据类型 属性名 ;（String name;） 属性定义并赋值的格式：         数据类型 属性名 = 初始化值 ;(String name ="张三";) 方法定义格式：         权限修饰符 返回值类型 方法名 ( 形式参数列表 ){         //方法体         return 返回值； }

package last302;

public class Bleiyuduixiangchuanjian1 {

	public static void main(String[] args) {
		
		//创建对象的格式：
		Person p =new Person();
		
		//对象属性赋值
		//格式 ：  对象名.属性名 =值；
		p.name="赵新坤";
		p.age=22;
		p.sex='男';
		p.say();
		
		int s =p.sum(1124,813);
		System.out.println(s);
	}

}
/**
 * 类就是图纸
 * */
//书写创建类
class Person{
	//属性 --特性
	String name;
	int age;
	char sex;
	
	
	//方法  -- 行为
		/**
		 * 定义格式：
		 * 返回值类型 方法名称(形式参数表){
		 * 方法体
		 * return 返回值；
		 * }
		 * 
		 * 
		 * 调用格式：
		 * 对象名.方法名称(实际参数列表);
		 * 
		 * */
	//空返回值方法
	void say(){
		System.out.println("我的名字叫做："+name+"我的年龄为："+age+"我的性别是："+sex);
	};
	
	//有返回值类型的方法
	int sum(int x,int y) {
		int z =x+y;
		return z;
	};
}

对象创建

一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下 :         类名称 对象名称 = new 类名称 () ; 如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：         访问类中的属性： 对象. 属性 ;         调用类中的方法： 对象. 方法 ( 实际参数列表) ;         

package last302;

public class Cduixiangchuangjianbuchong {

	public static void main(String[] args) {
		Book b1 = new Book();
		Book b2 = new Book();
		b1.name = "金苹果";
		b1.info = "讲述了果农种植金色苹果的辛勤路程。";
		b2.name = "银苹果";
		b2.info = "讲述了果农种植银色苹果的辛勤路程。";
	
		b1.say();
    	b2.say();
		
	}
}
	class Book{
		String name;
		String info;
		
		void say() {
			System.out.println("书的名字叫："+"书的简介："+info);
		}
	}

对象创建内存

此处涉及栈，堆，以及方法区的知识，请自行了解，谢谢。

package last302;

public class Dduixiangchaungjianneicun {

	public static void main(String[] args) {
		Boook b1 = new Boook();
		b1.name = "金瓶梅";
		b1.info = "教育书籍";
		b1.say();
		
		Boook b2 = b1;
		b2.name = "嘿嘿嘿";
		b1.say();
		
	}
}

class Boook{
	String name;
	String info;
	
	void say(){
		System.out.println("书名："+name+",简介："+info);
	}
}

package last302;

public class Eduixiangchuanjianneicun03 {

	public static void main(String[] args) {
		red b1 = new red();
		b1.name = "金瓶梅";
		b1.info = "嘿嘿嘿";
		
		red b2 = new red();
		b2.name = "水浒传";
		b2.info = "梁山好汉的故事";
		
		b2 = b1;
		b2.name = "西游记";
		b1.say();
		
		//此处主要讲解的就是关于栈，堆，以及方法区的细节以及GC垃圾回收的机制问题
	}

}

class red{
	String name;
	String info;
	
	void say() {
		System.out.println("书名"+name+"，简介："+info);
	}
}

构造方法

回顾对象的创建

Person p = new Person(); 在右侧 Person 后面出现的小括号 , 其实就是在调用构造方法 !

概述

作用： 用于对象初始化。 执行时机： 在创建对象时 , 自动调用 特点： 所有的 Java 类中都会至少存在一个构造方法 如果一个类中没有明确的编写构造方法 , 则编译器会自动生成一个无参的构造方法 , 构造方法中没有任何的代码！ 如果自行编写了任意一个构造器 , 则编译器不会再自动生成无参的构造方法。

定义格式

与普通方法基本相同 , 区别在于 : 方法名称必须与类名相同 , 没有返回值类型的声明 !

//案例
public class Demo3{
        public static void main(String[] args){
                Person p = new Person();
                p = new Person();
                p = new Person();
                p = new Person();
        }
}
class Person{
        public Person(){
                System.out.println("对象创建时,此方法调用");
        }
}

package last302;

public class Fgouzaofangfa {

	public static void main(String[] args) {
		System.out.println("1");
		Person2 p1 = new Person2("我是张三啊");
		System.out.println("2");
		//p1.name = "张三";
		p1.age = 18;
		p1.say();
		
		

	}

}

class Person2{
	//此处当我们没有设置构造方法的时候，系统会自动声称一个无参的构造方法
	String name;
	int age;
	//现在我们自己设置一个有参的构造方法试试
	Person2(String n){
		//System.out.println("我执行了");
		name = n;
	}
	
	void say(){
		System.out.println("自我介绍。我是"+name+"我的年龄为："+age);
	}
}

注意：

建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。 当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。 当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

方法的重载

重载条件：

方法名称相同 , 参数类型或参数长度不同 , 可以完成方法的重载 ! 方法的重载与返回值无关 ! 方法的重载 , 可以让我们在不同的需求下 , 通过传递不同的参数调用方法来完成具体的功能。

package last302;

public class Gfnagfadechongzai {

	public static void main(String[] args) {
		Math b1 = new Math() ;
		int num = b1.sum(100, 120);
		System.out.println(num);
		
		double num2 = b1.sum(100.11, 120.22);
		System.out.println(num);

	}

}
/**
 * 关于方法的重载问题
 * 首先类的命名要规范，做到见明知意
 * 
 * 
 * 一个类中定义的方法，是允许重载（相同的方法名称）
 * 
 * 1.方法名称相同
 * 2.参数列表长度 或参数列表类型 或（参数类型顺序不同）
 * 
 * 注意：与返回值类型无关*/

class Math{
	
	int sum(int x, int y){
		int z = x +y;
		return z;
	}
	
	double sum(double x, double y){
		double z = x +y;
		return z;
	}
	
	double sum(double y ,int x) {
		double z = x + y;
		return z;
	}
}

构造方法重载

一个类 , 可以存在多个构造方法 : 参数列表的长度或类型不同即可完成构造方法的重载 。 构造方法的重载 , 可以让我们在不同的创建对象的需求下 , 调用不同的方法来完成对象的初始化 !

package last302;

public class Hgouzaofangfadechongzai {

	
	/**
	 * 一个类, 可以存在多个构造方法 :
	 *  参数列表的长度或类型不同即可完成构造方法的重载.
	 * 可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化!
	 * */
	public static void main(String[] args) {
		Person3 z = new Person3("张三",18);
		z.say();
		
		Person3 x = new Person3("赵四");
		x.say();
		
	}

}

class  Person3 {
	
	
	Person3(String name2,int age2){
		name = name2;
		age = age2;
	}
	
	Person3(String name2){
		name = name2;
		
	}
	
	
	String name;
	int age;
	
	
	
	void say() {
		System.out.println("name is" +name+"age is"+age);
	}
}

匿名对象

没有对象名称的对象 就是匿名对象。 匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被 G·C 回收。 只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。

package last302;

public class Inimingduixiang {
//匿名对象就是没有名字的对象
	public static void main(String[] args) {
	
		//按照平时的习惯，我们一定会这样来声明和调用对象
		/**
		 *Math2 m = new Math2();
		 *int num = m.sum(100, 200);
		 * System.out.println(num);
		 * */
		
		//现在书写一个新的，没有名字的对象直接调用方法
		int num = new Math2().sum(100, 200);
		System.out.println(num);
	}

}


//首先写一个类
class Math2{
	
	int sum(int x,int y) {
		return x+y;
	}
}

误区

package last302;

public class Jnimingduixiang2 {

	public static void main(String[] args) {
		
		
		//创建对象误区
		new Person4().name = "张三";
		new Person4().age = 18;
		new Person4().say();
		
	 //像这样就是不对的，因为这样去创建的话就相当于在堆内存中创建了三个不同的空间
		
		
	}

}
class Person4{
	String name;
	int age;
	
	void say() {
		System.out.println("自我介绍："+name+"年龄为"+age);
	}
	
	
}