封装，继承，多态

封装

基本类型与引用类型

//int a=5; int b=a;将变量a的值，拷贝一个给变量b，变量a与变量b是相互独立的；
//int[] a={1}; int[] b=a;
//将数组a引用的地址，拷贝一个副本给数组b，数组a与数组b相互关联，都指向同一个数组；
//Student a=new Student();Stedent b=a;同数组

object oriented programming
		//抽象：模具
		//类：class

类

1.访问修饰符

访问修饰符 [abstract/static/final....] class/interface/enum 类名称 {}

2.属性

静态特征、成员变量、全局变量

3.方法

访问修饰符 [static/final/volatile/transient...]数据类型 属性名称;
1、程序运行时，自动为属性赋无效的初值，同数组的初始化
		  方法、动态特征、函数、行为
访问修饰符 [abstract/static/final/native....] 返回类型 
方法的名称（[形式参数列表]）{方法体}
形式参数：定义类型，数量，顺序

（1）入口方法：程序的入口

public static void main(String[] args){..}

（2）构造方法：初始化（赋值）

public 与类同名([形式参数列表]){...}
//构造方法的重载
//同一个类中，方法名称相同，参数不同（数量不同，类型不同，不同类型顺序不同）//写代码

（3）自定义方法

//使用方法：功能，参数，返回值
//创建方法：方法的源码
void:方法无返回类型
/方法的返回值：只能有一个
return [值]；
1、终止方法2、返回值
//方法的入参规则：可以有多个
	//三个以内，直接入参
	//3个以上，封装入参

4.this关键字

当前对象，在同类中某构造方法中通过重载调用其他构造方法，且必须为第一句。

对象

//创建对象
	//实际参数：定义值
	类 对象名称=new 构造方法([实际参数列表]);
	new //一般是引用类型，一般是地址；
//访问对象
	//外部访问
		//访问对象的{可见}属性
		对象名称.属性名称
		//访问对象的{可见}方法
		对象名称.方法名称{实际参数列表}
	//内部访问：直接访问

1.类的认知

//GC JVM垃圾回收器
	//数据类：实体类
		//				类型   			数值
		//变量			1				1
		//数组			1				n
		//类			n（个对象）		1（描述了1个对象）
		//对象数组		n				n
	//业务类

2.static

和基本类型的存在，证明Java不是存粹的面向对象语言
优点：方便跨类调用
缺点：违背oop.
8.基本类型对应的包装类

	基本类型      	包装类				扩展方法
	String			String
	char			Character
	byte			Byte
	short			Short
	int				Integer				 int Integer.parseInt(String s);
	long			Long
	float			Float
	double			Double
	boolean			Boolean
	

继承

1. 目标：

//代码的重用性
//耦合度
//扩展性

继承 extends  (继承是为了重用，更是为了扩展)
		class B{}
		class A extends B{}
		所有类的祖宗：object
		单根继承
		凡是符合“Xxx is a Yyy” class Xxx extends Yyy{}
		super 父类的对象，或者调用父类的构造方法，且必须为第一句。
		继承本质：每一个子类对象中都有一个独有的父类对象，由虚拟机负责创建。

父类不可继承内容

	//私有
			//构造方法 super(...)
			//访问修饰符		类			同包  		异包子类		其它(异包非子类)		
			public				✔			✔				✔				✔
			protected			✔			✔				✔				
			default(无)			✔			✔
			private				✔			

继承关系不同性质代码执行顺序（父>子/静态>普通>构造）

父类静态代码块
子类静态代码块
父类普通代码块
父类构造方法
子类普通代码块
子类构造方法

多态

//概念：一种类型多种表现形态
//必要条件：
//继承
//重写
//子类重写父类的方法：参数，返回值完全相同，访问权限>=父类
//类型转换
//☆自动类型转换：子类对象给父类引用
//强制类型转换：将父类引用指向的子类引用，转化为子类对应的实际引用；

			boolean is=objectA instanceof class B
			((classB)objectA)

//重载也是多态

抽象类与接口

抽象类

		抽象类：abstract修饰的类就是抽象类
		public abstract class A{}
				//不可以直接实例化
				//可以有构造方法，可以有属性，可以有自定义方法；
				//可以有抽象方法，子类必须重写抽象父类的抽象方法，除非子类也是抽象方法；

接口

public interface A{}
		//特征：：不可以直接实例化
		//不可以有构造方法，可以有属性，属性默认为公共的，静态的常量；可以有自定义方法，方法默认为公共的，抽象的；
		//实现类（子类）必须重写父接口的所有方法，除非实现类是抽象类或接口
	//应用场景
			//是一个/is  a    A extends[abstract] B     重用
			//有一个/has a  A implements interface B  扩展
			//面象修改是封闭的，面象扩展是开放的。

异常

异常：阻止项目正常编译或运行的现象

		Error:系统级异常
			StackOverflowError
			OutOfMemoryError
			InterruptedException
			...
		Exception
			ComplieException：编译异常
				流
				线程
				java连接操作数据库
			RunTimeException：运行时异常
				InputMismatchException
				ArrayIndexOutOfBoundsException
				ArithmeticException
				NumberFormatException
				ClassCastException
				...

异常处理的方式

	//非编译异常：推荐使用程序逻辑规避异常的发生
			比如：
					Integer.parseInt(String val)
				//产生异常的原因：字符串val不符合整数的特征
				 private static boolean isInt(String str){
					for(int i = 0; i<str.length() ; i++){
					char c = str.charAt(i);
					if(!Character.isDigit(c)){
						return false;
					}
					}
					return true;
				}
				
			//比如：
					int [] arr={22,33,44}
					public int get(int index){return arr[index]}
				//	产生异常的原因：整数参数index不在0~arr.length-1的范围内
					private boolean outOfBounds(int index){
						return index<0||index>arr.length-1;
					}

try-catch

try{
				
			}catch(XxxException1 e){//catch的数量取决于代码段中可能产生的异常种类
									//如果不同种类的异常，必须不同处理，则必须多个catch处理
			}catch(XxxException2 e){//即使存在不同种类的异常，但可以用同一种处理方式，则用一个catch即可
				
			}catch(XxxException3 e){
				
			}
			xxx....
			
			public xxx method(xxx xxx) throw XxxException{//如果选择抛出异常，必须为编译异常
				//系统预定义异常：自动抛出
				//自定义异常：必须手动抛出
				throw new XxxException("....");
			}

			//自定义异常：public class XxxException extends Exception/RunTimeException(){..}