Java面向对象

一、 面向对象

面向对象是一种认识事物的方式，注重对事物整体的认识，最符合人类自然的思维方式
面向对象：
1.对象是属于类的一个实例
2. 一切皆对象
3. 对象的三特征：

对象的行为(behavior）
对象的状态(state)
对象标识(identity)

优点：

耦合度低，扩展力强，更容易解决现实世界当中更复杂的业务逻辑。

缺点：

性能比面向过程低

面向对象生命周期

OO：面向对象
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程

二、封装

概念：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装步骤：
1.使用private关键字进行修饰，修饰的所有数据只能在本类中访问
2.对外提供两个公开的方法：get和set
get方法命名的规范：

  public int getAge(){
  ​ return age
}

set方法命名的规范：

  public void  setAge(int age){
  this.age=age;
  }

get方法根据方法需要，提供相应的返回值
set方法没有返回值，因为set方法只负责修改属性值

Java访问修饰符

Java 中有四种：主要是 private、protected、public 和 默认访问权限
public 修饰符，具有最大的访问权限，可以访问任何一个类、接口等。
protected 修饰符，主要作用就是用来保护子类，子类可以访问这些成员变量和方法，其余类不可以。
default 修饰符，主要是本包的类可以访问。
private 修饰符，私有的，访问权限仅限于本类内部，在实际开发过程中，大多数的成员变量和方法都是使用 private 修饰的。

this关键字

this一般我们都用在类中，他的主要其实就是起到一个指代的作用。
我们在类中,不知道当前是哪个对象在调用( this就表示当前调用的哪个对象)
this 不能使用在带有static的方法中
this（参数列表）调用具有对应参数列表的构造方法

构造方法(或构造函数、构造器，constructor)

1、构造方法的格式:

public 类名(){}

构造方法调用： new 构造方法名(实参列表)

2、对于构造方法来说，“返回值类型”不需要指定，并且不能写void，只要写上void，则这个方法变成普通方法

public void 类名(){}

普通方法的调用：方法修饰符中有static时，类名.方法名（实参列表）；方法修饰符中没有static时，引用.方法名（实参列表）

构造方法作用
1、创建对象
2、创建对象的同时，初始化对象的信息

三、继承

概念:

一个新的类从已有的类那里获得其已有的属性和方法，这叫继承(子类继承父类)父类中能够被访问的属性和方法能够直接在子类中或者子类对象访问。当然,子类如果还有子类的话,这个孙子辈的类,同样也继承了最上层父类里面的内容。简单来说,继承是依次往下的,最下面的子类,可以访问到上面所有父类允许被访问的内容

继承的好处

1.1 简化代码,减少代码冗余
1.2 多态的实现

语法结构

class 子类 extends 父类{}
如下：B继承A类的所有属性和方法

class A{
public void f(){
System.out.println(“AAAA\n”);
}
}

class B extends A{
public void f(){
System.out.println(“BBBB\n”);
}
}

继承的规定与扩展

Java只能单继承，不能多继承
子类拥有父类非private的属性、方法
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
子类可以用自己的方式实现父类的方法或者属性–重写

方法的重写（Override/Overwrite）

重写特征:

1.继承
2.子类重写父类的方法(可以对父类中同名同参数的方法，进行覆盖操作)
3.方法名一样,参数一样
4.返回值一样(如果函数名和参数一样,返回值不一样的话,其实就触发了同名函数的错误)

注意细节:

在eclipse中只要是子类重写的方法,在旁边会有一个绿色的三角
私有方法不能继承，所以不能覆盖
构造 方法不能继承，所以不能覆盖
静态方法不存在覆盖。
覆盖只针对方法，不针对属性

重写的好处:

1.减少冗余,不需要写其他的名字的方法
2.可以实现后面的多态
在子类的内部,如果想调用父类的方法,可以使用super关键字

super关键字

1、super表示父类对象
2、可以调用属性和方法
super的应用：
super表示调用父类构造方法，产生父类对象。这句话必须是子类构造方法的第一句。
子类重写了父类方法以后，会优先调用子类重写的方法。但是，父类的方法并没有消失，可以通过super.方法名()，调用父类的方法。

final关键字

1. final 修饰类，表示该类不能被子类所继承
2. final修饰方法，表示该方法不能被子类重写
3. final修饰变量，表示该变量的值不能改变
4. final 修饰属性，表示该类的该属性不会进行隐式的初始化，所以该final 属性的初始化属性必须有值。初始化之后就不能改了，只能赋值一次。

子类对象实例化过程

1、子类继承父类以后，就获取了父类中声明的属性或方法
2、如果子类和父类有同名成员变量和方法，子类可以使用 super 关键字调用父类的成员变量和方法

四、多态

概念

是指不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式

多态存在的必要条件

1、要有继承；
2、要有重写；
3、父类引用指向子类对象。

abstract关键字

1、abstract:抽象的
2、abstract可以用来修饰的结构：类、方法

接口

接口可以看做是抽象类的特例。抽象类中可以定义抽象方法，可以定义具体方法。在接口中能定义抽象方法，接口可以看做是行为的抽象
接口中只能定义public abstract方法。默认也是public abstract方法。不能用protected和privatc修饰接口方法

内部类

1.Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2.内部类的分类：成员内部类（静态、非静态）。 局部内部类(方法内、代码块内、构造器内)

好处：

1、多态对已存在的代码具有可替换性
2、增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作
3、接口性，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的
4、Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载

例如:我家里养了二只动物,会吃，会睡

//定义父类
public class Animal {
	   //睡
		public void sleep() {
			System.out.println("AnimalSleep");
		}
        //吃
	    public void eat() {
	    	System.out.println("AnimalEat");
	    }		
}

//定义子类 Dog
public class Dog extends Animal{
	//子类重写父类方法eat
	 public void eat() {
	    	System.out.println("狗爱吃骨头");
	    }
	 public void sleep() {
			System.out.println("狗爱睡觉");
		}	
    //子类还可以扩展Dog类独有的方法
	 public void bite(){
		 System.out.println("狗会咬恶人");
	    } 
}

//定义子类 Cat
public class Cat extends Animal{	
	//子类重写父类方法eat
	 public void eat() {
	    	System.out.println("猫爱吃猫粮");
	    }
	 public void sleep() {
			System.out.println("猫爱睡觉");
		}
}

多态总结：
1、使用父类类型的引用指向子类的对象
2、该引用只能调用父类中定义的方法，不能调用子类中独有的方法
3、如果子类中重写了父类中的一个方法，那么在调用该方法的时候，将会调用子类中的这个方法
4、在多态中，子类可以调用父类中的所有方法
5、多态主要体现为重载和重写。相同的行为不同的实现方法
6、多态主要应用未多态参数和多态集合