面向对象总结

1.面向对象：

1.抽象

	同一类型的事务的抽象，形成类。
	类的定义：
		语法：
			public [修饰符] class className{
				1.成员变量
				2.成员方法
				3.构造方法
				[4.类方法(静态方法)
				5.类变量(静态变量)]
			}
		修饰符：final，abstract，static
	方法定义:
		语法：
			public [修饰符] 返回值类型 methodName([参数列表]){
				[return 值]
			}
		
			public void test(){
				//无参数，无返回值类型的方法
			}
			public void test(int i,int j){
				//无返回值类型，带参数的方法
			}
			public String test(String[] args){
				//带返回值类型，带参数
				return String;
			}

		参数：
		      1.基本数据类型
			1> byte字节
			2> short 短整型
			3> int 整形
			4> long 长整型
			5> float 单精度浮点型
			6> double 双精度浮点型
			7> char 字符型
			8> boolean 布尔型 (true/false)

		      2.引用数据类型
			1> 类 String 
			2> 接口 
			3> 数组

		返回值类型：
			1> void 无返回值类型
			2> 带返回值类型
				1.基本数据类型
					1> byte字节
					2> short 短整型
					3> int 整形
					4> long 长整型
					5> float 单精度浮点型
					6> double 双精度浮点型
					7> char 字符型
					8> boolean 布尔型 (true/false)

				2.引用数据类型
					1> 类 String 
					2> 接口 
					3> 数组

				3.return关键字
					return后的类型和定义的方法的返回值类型必须一致，null
				4.返回值的接受
					当调用带返回值类型方法的时候，必须要用和反正类型一致的类型的变量去接受它。

2.封装

	把对象中的公共属性进行隐藏，从而实现对属性的封装(保护)，为了安全。
	实现方式：
		对属性的访问修饰符进行限制：private
			private 特性:只有在该类内部才能访问。
		提供私有属性对外访问的方法：
			setXXX和getXXX方法
			setXXX方法：主要用于外部的类改变私有属性的值
			getXXX方法：主要用于外部的类获取私有属性的值

			private String name;
			//get和set方法
			public void setName(String name){
				this.name = name;
			}
			public String getName(){
				return this.name;
			}

	对构造函数的封装：
		直接把构造函数设置成私有的 private。
		提供一个静态的返回该类类型的方法。
		案例：单例模式

3.继承

	父类和子类之间的一种关系。
	子类可以继承父类的公共属性和方法。
	被继承的类称为基类或者超类或者父类。
	继承的类称为子类。
	
	1> 子类可以使用父类私有以外的所有成员变量
	2> 子类可以拥有父类私有以外的所有成员方法

	3> 方法的覆盖(重写)
	   1) 存在继承关系
	   2) 方法名，参数，返回值类型相同
	   3) 访问修饰符：子类要大于或等于父类的访问修饰符

	   public class Person{
		public void eat(String food){
			
		}
	   }

	   public class Men extends Person{
		@Override //表示该方法是被重写的方法
		public void eat(String food){
		
		}
	   }

3.多态：

	类或方法的多种形态的体现。

	1.方法重构/重载
	  1) 在同一个类中
	  2) 方法名相同，参数列表不同

	2.类的向下转型
	  父类引用可以实例化子类的对象。
		SuperClass sc = new SubClass();
	  调用子类的方法
	  调用哪个子类的方法：根据new 后面的类来确定。

	  父类的引用可以强制转换成它实例化的子类的对象。

	  Men men = new Men();
	  Person peron = (Person)men;
	  可以转换但是调用发方法的时候，会出现异常。

	  Person person = new Men();
	  Men men = (Men)person;

2.修饰符：

1. static ：静态的，全局的，属性类的

	1.静态的变量
		语法：
			public static String name; //类变量
		调用：
			类名.静态变量名
	2.静态的方法
		语法：
			public static String methodName(参数类别){
				return String;
			}
		静态方法的调用：
			在同一个类中，可以直接写方法名调用。
			不在同一个类中，类名.方法名调用

			Person.methodName("zhangsan");
			//普通方法的调用
			Person person = new Person();
			person.methodName(); //对象名.方法名()调用

2. abstract：抽象的

		1 抽象类
			public abstract class ClassName{
				//可以有抽象方法
				//也可以全部是普通方法
			}
		2 抽象方法
			public abstract String methodName(){
				//抽象方法必须定义在抽象类或接口中
			}
			如果该类中有抽象方法的话，该类必然是抽象类/接口
		3.抽象类不能被直接实例化
			要通过继承该抽象类的子类进行实例化。

3.final:最终的

		1 最终类
			用final关键字修饰的类。
			该类不能被继承。
			语法：
				public final class ClassName{
				
				}
		2 最终方法
			用final关键修饰的方法
			该方法不能被重写
			语法：
				public final void methodName(){
				
				}
		3 最终变量(常量)
			常量值一旦定义不能被改变
			常量命名规范：一般所有的字母全部大写

3.接口：

	主要用于定义开发规范（大框架)
	关键字：interface

	语法：
		public interface MyService{
			//常量
			//抽象方法
			//default方法（jdk1.8新特性）
				默认方法通过实现类对象调用
			//静态方法（jdk1.8新特性）
				静态方法通过接口名调用
		}
实现类：
	主要用于实现接口。
	关键字：implements
	实现类一定要重写接口的所有的抽象方法。
	抽象方法：只有方法声明，没有方法体。

	实例化：
		接口名 接口的引用 = new 实现类();

4.Lambda表达式：

	也叫函数式接口，提供对接口的实现。
	语法：
		接口 接口的引用 = ([参数列表]) -> { 语句块 }

	@FunctionalInterface 注解：
		判断当前接口是否符合lambda表达式的实例化要求
	
	实例化：new关键字的使用
	当接口的方法返回某个指定类对象的时候，可以直接用类名::new关键字实现

	语法：
		接口 接口的引用 = 类名 :: new;
		接口的引用.方法名();

	主要作用：
		1.接口方法的实现
		2.应用范围很广
			比如：对象数组的排序
			      集合的排序等等

抽象类和接口的区别：
	1.继承关系，类的继承机制是单继承，接口是多继承
	2.方法方面：抽象类可以有普通方法也可以有抽象方法，接口只能有抽象方法（默认和静态）
	3.变量：抽象类可以有普通成员变量和常量，接口只能有常量
	4.定义上：抽象类型使用abstract关键字，接口使用interface关键字
	5.实现上：继承使用extends关键字，实现使用implements关键字