面对对象基本思想

面向对象

面向“过程”思想：

• • 步骤简单清晰，第一步做什么，第二步做什么
  • 面对过程适合处理一些较为简单的问题。

面向“对象”思想

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

注意：对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象编程（Object Oriented Programming）简称OOP。
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
• 抽象
• 三大特性：
• • 封装
  • 继承
  • 多态
• 从认识的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类，后有对象。类是对象的模板。

方法的定义

• 修饰符
• 返回类型
• break：跳出循环，结束循环和return有区别。
• 方法名：注意规范 （见名知意）
• 参数列表：（参数类型，参数名）
• 异常抛出

方法的调用：递归

• 静态方法（加了static关键字）

  public static void ergodic(int[]array) //数组作为方法入参
  	{
  
      for(int a:array)
      System.out.println(a);
  	}
  

• 非静态方法（没有static关键字）

  public  void ergodic(int[]array) //数组作为方法入参
  	{
  
      for(int a:array)
      System.out.println(a);
  	}
  

• 形参和实参

  public static void main(String[] args) 
  	{
  		a(2, 3);//这里面的两个参数2和3就是实参
  		
  		
  	}
  	public static void a(int a,int b) //这里的两个参数就是形参
  	{
  		
  		System.out.println(a+b);
  	}
  

• 值传递

  public static void main(String[] args) 
  	{
  		int a=1;
  		a(a);
  		System.out.println("a最后的值为什么还是："+a);//这个就叫值传递
  		
  	}
  	public static void a(int a) 
  	{
  		a=100;
  		System.out.println("这里a变成了一百了");//回到main方法之后值就变回原来主方法的值1了
  	}
  

• 引用传递

  public class ShiYan {
  
  	public static void main(String[] args) 
  	{
  		Name name=new Name();
  		System.out.println(name.name);//这里张三还叫张三
  		a(name);
  		System.out.println(name.name);//这里就变成了李四，这个就叫做引用传递，值会改变，值传递则不会改变。
  	}
  	public static void a(Name name) 
  	{
  		name.name="李四";
  	}
  	
  	
  }
  class Name{
  	String name="张三";
  }
  

• this关键字：

  1、代表当前对象

  2、this就是所在函数所属对象的引用，简单来说，哪个对象调用了this所在的函数，this就代表哪个对象

      public String name;
      public int age;
      public ShiYan(String name, int age){
          this.name = name;
          this.age = age;
      }
  

类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物：
• • 动物、植物、手机、电脑…
  • Person类、pet类、car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
• 对象是抽象概念的具体实例：
• • 张三就是人的一个具体实例，张三家的汽车就是车车的一个具体实例。
  • 能够体现出特点，展现出功能是具体的实例，而不是一个抽象的概念。

创建与初始化对象

• 使用new关键字创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对线进行默认的初始化以及对类中构造器的调用。

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

• • 1.必须和类的名字相同
  • 2.必须没有返回类型，也不能写void

• 构造器必须掌握（程序员必须掌握的基本，类似武学之中的筑基）

• 切记面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据。

• 在eclipse中按快捷键 alt + shift + s 选择generate constructor using fields。然后在弹出框中选择成员变量 即可快速创建构造方法。

public class Student {
	String name;
	int age;
	public Student()//无参构造
	{
		this.name="李四";
		this.age=24;
	}
	public Student(String name,int age)//有参构造
	{
		this.name=name;
		this.age=age;
	}
}

public class ShiYan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student student3=new Student();//直接调用无参的构造方法
		Student student1=new Student("小红",12);//初始化Student并且把小红和12给到Student的构造方法
		Student student2=new Student("小明",12);//初始化Student并且把小明和12给到Student的构造方法
		
		System.out.println(student3.name);
		System.out.println(student3.age);
		System.out.println(student1.name);
		System.out.println(student1.age);
		System.out.println(student2.name);
		System.out.println(student2.age);
	}

}

封装

• 程序要求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作借口来访问，这称为信息隐藏。
• 属性私有，get/set

public class Student {
	private String name;
	private int age;
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}
	
	
	
}

public class ShiYan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student student=new Student("小红", 12);//直接调用无参的构造方法
		
		
		System.out.println(student.getName());
		System.out.println(student.getAge());
		
	}

}

• 封装的好处：

public class Student {
	private String name;
	private int age;
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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>100||age<0) //封装可以提高程序的安全性
		{
			this.age = age;
		}else 
		{
			System.out.println("你输入的年龄不合法");
		}
		
	}
	
	
	
}

public class ShiYan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student student=new Student("小红", 12);
		
	
		
		student.setAge(666);
		System.out.println(student.getAge());
		student.setAge(60);
		System.out.println(student.getAge());


	}

}

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”，子类是父类的扩展。
• Java里面类只有单继承，没有多继承！
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有“is a”的关系。
• object类、super、方法重写。
• 私有的东西无法被继承

Super 和this

• 调用父类的构造器，必须在子类构造器的第一行。
• super 必须只能出现在子类的方法或者构造方法中！
• super和this不能同时调用构造方法
• this()；本类的构造
• super(); 父类的构造

代表的对象不同

• this：本身调用者这个对象
• super：代表的父类对象的应用

前提

• this：没有继承也可以使用
• super：只能继承条件下才可以使用

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

多态存在的条件：

• 有继承关系
• 子类重写父类的方法
• 父类引用指向子类对象（简单来说，就是父类型可以指向子类，但是不能调用子类的方法）

注意：多态是方法的多态，属性是没有多态的

简单来说就是对象能执行那些方法，主要看对象左边的类型，和右边关系不大！

方法的重写

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：可以扩大，但是不能缩小
4. 抛出的异常：范围，可以被缩小，但不能扩大。
5. 需要有继承关系，子类重写父类的方法

为什么需要重写：

父类的功能，子类不一定需要，或者一定不满足。

另外注意：

1. static 方法属于类，它不属于实例。
2. final常量
3. private 方法

这三位是不能被重写的，不能重写就没有多态。

类型转化

1. 子类转换为父类，可能会丢失一些方法。
2. 父类转化为子类是可以的，一般是为了减少重复的代码。