JAVA-OOP

//基本类型和引用类型
int a = 5; int b =a;将变量a的值，拷贝一个副本给变量b，变量a和b是互相独立的。
int[] a ={1}; int[] b = a; 将数组a引用的地址，拷贝一个副本给数组b，数组a和b指向同一个数组。
Student a = new Student(); Student b =a; 同数组

//oop:object oriented programming
//抽象: 模具（类）
//类：class
//访问修饰符 [abstract/static/final…] class/interface/enum 类名称{
//属性、静态特征、成员变量、全局变量
//访问修饰符 [static/final/volatile/transient…] 数据类型 属性名称；
//1、程序运行时：自动为属性赋无效的初值，同数组初始化
//方法、动态特征、函数、行为
//访问修饰符 [abstract/static/final/native…] 返回类型 方法名称([参数列表]){方法体}
//形式参数：定义类型，数量，顺序
//1、入口方法:程序的入口
public static void main(String[] args){…}
//2、构造方法：初始化(赋值)
public 与类同名([形式参数列表]){…}
//构造方法的重载：
//同一个类中
//方法名称相同
//参数不同（数量不同，类型不同，不同类型顺序不同）
//3、自定义方法
//使用方法:功能，参数，返回值
//创建方法：方法的源码
void：方法无返回类型
//方法返回值：只能有一个
return [值]; 1、终止方法 2、返回值
//方法入参规则：可以有多个
//3个以内，直接入参
//3个以上，封装入参
//}
//this关键字:当前对象,同类中某构造方法中通过重载调用其他构造方法，且必须为第一句。

//object
//创建对象
//实际参数：定义值
类 对象名称 = new 构造方法([实际参数列表]);
//访问对象
//外部访问
//访问对象的【可见】属性
对象名称.属性名称
//访问对象的【可见】方法
对象名称.方法名称([实际参数列表])
//内部访问:直接访问
//类的认知
// GC
//数据类：实体类
// 类型 数值
//变量 1 1
//数组 1 N
//类 N 1
//对象数组 N N
//业务类

//static和基本类型的存在，证明Java不是纯粹面向对象的语言
//static
//优点：方便跨类调用
//缺点：违背OOP，声明周期
//基本类型对应的包装类
基本类型 包装类型 扩展方法
String String
char Character boolean is = Character.isDigit(char c); //c是否为数字
boolean is = Character.isLetter(char c);//c是否为字符（不区分大小写）
byte Byte
short Short
int Integer int val=Integer.parseInt(String str);
long Long
float Float float val = Float.parseFloat(String str);
double Double
boolean Boolean

//OOP
//目标：
//重用性（重复部分放一起）
//耦合度（类和类间的依赖关系越低越好）
//扩展性（能够扩展程序功能）
//封装

//继承
class B{ }
class A extends B //继承是为了重用，更是为了扩展
//所有类的祖宗：Object
//单根继承
//凡是符合"Xxx is a Yyy" class Xxx extends Yyy{ }
//super 父类对象，调用父类构造方法，且必须为第一句。
//本质：每一个子类对象中都有一个独有的父类对象，由虚拟机负责创建。
//父类中不可以继承的内容
//构成方法 super{…} 子类调父类构造方法只有借助super
//访问修饰符 类内 同包【子类】 异包子类 其他（异包非子类）
public 可以 可以 可以 可以
protected 可以 可以 可以
default(无) 可以 可以
private 可以
//继承关系不同性质代码执行顺序（父>子 / 静态>普通>构造）
父类静态代码块
子类静态代码块
父类普通代码块
父类构造方法
子类普通代码块
子类构造方法
//多态
//概念：一种类型多种表现形态
//必要条件：
//继承
//重写
//子类重写父类的方法（参数、返回值完全相同，访问权限>=父类）
//类型转换
//自动类型转换：子类对象给父类的引用
//强制类型转换：将父类引用指向的子类对象，转化为子类对应的实际引用 boolean is =objectA instance of classB
((classB)objectA).特有行为
//重载（super）也是多态

//抽象类和接口
//抽象类：abstract 修饰的类就是抽象类
public abstract class A{
public abstract int cal(int a,int b);
}
抽象类特点：
//不可以直接实例化
//可以有构造方法，可以有属性，可以有自定义方法
//可以有抽象方法，子类必须重写抽象父类的抽象方法，除非子类也是抽象类
//接口
public interface A{ }
接口特点：
//不可以直接实例化
//不能有构造方法，属性默认为公共的静态的常量，方法默认为公共的抽象的
//实现类（子类）必须重写父接口的所有方法，除非子类是抽象类或接口

//应用场景
//是一个 /is a A extends [abstract] B 重用
//有一个/ has a A implements interface B 扩展
//面向修改是封闭的，面向扩展是开放的

//异常
//异常：阻止项目正常编译或运行的现象
Error ：系统级异常
StackOverflowError
OutOfMemoryError
InterruptedException
…
Exception
CompileException:编译异常
流
线程
Java连接操作数据库
RuntimeException:运行时异常

//异常处理方式
//非编译异常：推荐使用程序逻辑规避异常的发生
//比如：Integer.parseInt(String val)
//产生异常的原因，字符串val不符合整数的特征

			//比如： int[] arr = {22,34,15};
					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{
				 //可能出现异常的代码段
					xxx ...
					xxx ...
					xxx ...
				}catch(XxxException e){ //catch的数量取决于代码段中可能产生异常的种类数
				  
				}catch(XxxException e){ 
					
				}catch(XxxException e){
					
				}
				xxx ...
				
				public xxx method(xxx xxx) throws XxxException{ //如果选择抛出异常，必须为编译异常
					//系统预定义异常：自动抛出
					//自定义异常：必须手动抛出
					throw new XxxException("...");
				}
				
				//自定义异常： public class XxxException extends Exception/RuntimeException{...}

//final关键字
final int VALUE = 5; //常量
final void show(){}; //不可以重写
final void Xxx{} //不可以被继承
//内部类
//内部类可以自由访问外部类的任何内容，而外部类无法访问内部类的任何内容
class Xxx2{}
public class Xxx{
[public static final] class InXxx{} //内部类
}
Xxx.InXxx

//匿名内部类：创建抽象类或接口对象