我学完OOP之后对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.构造方法：初始化（赋值）x
public 与类同名 ([形式参数列表]){…}
//构造方法的重载：
//同一个类中
//方法名称相同
//参数不同（数量不同，类型不同，不同类型的参数顺序不同）
//3.自定义方法
//使用方法：功能，参数，返回值
//创建方法：方法的源码
void：方法无返回类型
//方法返回值：只能有一个
return [值]; 1.终止方法 2.返回值

					//方法入参规则：可以有多个
						//3个以内，直接入参
						//3个以上，封装入参
					
		//}
	//this关键字：当前对象，同类中某构造方法中通过重载调用其他构造方法，且必须为第一句。
	/*  public Student(String name,int age){
    this.name = name;
    this.age = age;
}

    public Student(String name,int age,float myMoney){
    this(name, age);
    this.myMoney = myMoney;
} */


	
	
		
		
		
//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的三大特性
//目标：
//代码的重用性
//耦合度（低耦合度比较好，低的依赖性）
//扩展性
//封装
写类的过程就是封装的过程
//继承 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 classB;（对象A是否是类B的实例）
((classB)objectA).specialAct();
//重载也是多态

//常用的字符串方法
//charAt(n) n取值范围：0~str.length()-1
//strA.equals(strB)
//String[] strs = str.split(strRegex); //以strRegex来分开数组中的元素
//String part = str.substring(beginIndex,endIndex); //截取字符串
//int len = str.length();

	public R<Order> findOrder(int state,int... userNo) {
		
		int... 参数
		表示动态参数，有且只能有一个参数

//抽象类和接口
//抽象的例子：

（老师举了A B C D四个例子，A为抽象父类，A定义了一个方法：会计算。B，C为子类，D类想用类B和类C的方法。B会加法，C会减法。D会计算）
public abstract class A(){

private String name;

public A(String name){
	this.name
}

public abstract int cal(int a,int b)；

}

public class B extends A(){
//子类B必须重写抽象父类的抽象方法
@Override
public int cal(int a,int b){
return a+b；
}
}

public class C extends A(){
//子类C必须重写抽象父类的抽象方法
@Override
public int cal(int a,int b){
return a-b;
}
}
public class D{
//D想用A的计算
public void cal(A a,int c,int b){
System.out.println(a.cal(c,b));
}
}
//测试类
public class Test{
public static void main(String[] args){
//instance实例
D d = new D();
d.cal(b,c:2,b:3);//得到的值为5
d.cal(c,c:2,b:3);//得到的值为-1
}
}

//抽象类：abstract修饰的类就是抽象类(父类通常是抽象的，不能实例化)
public	abstract class A{}
	//特征：
		//不可以直接实例化
		//可以有构造方法，可以有属性（留给子类使用），可以有自定义方法
		//可以有抽象方法，子类必须重写抽象父类的抽象方法，除非子类也是抽象类
//接口
	//public interface A {}
	//不可以直接实例化
	//不能有构造方法，属性默认为公共的静态的常量；方法默认为公共的抽象的，不能有方法体
	//实现类(子类)implements必须重写父接口的所有方法，除非子类是抽象类或接口
	
//应用场景
//是一个 （is a）   A extends [abstract] B		重用
//有一个（has a）	A implements interface B	扩展 （有一个类A，类B想扩展A的功能，那么先新建一个接口；再新建一个新的类（B）继承原来的类（A），再实现一个接口）
写接口的例子——Calculator

//给Calculator定义了一个带参方法
public class Calculator{
	public int add(int a,int b){
		return a+b;
	}
}

//Calculator2类想扩展Calculator类的方法,需要先新建一个接口MultiAdd
public interface MultiAdd{
	int add(int...arr);
}

//Calculator2类继承Calculator，实现MultiAdd
public class Calculator2 extends Calculator implements MultiAdd {
	
	@Override
	public int add (int...arr){
		int sum = 0;
		for(int i : arr){
			sum = add(sum,i);
		}
		return sum;
	}
}

//测试类
public class Test{
	public static void main(String[] args){
		Calculator2 c2 = new Calculator2;
	}
}



//面向修改是封闭的，面向扩展是开放的。

//异常
//异常：阻止项目正常编译或运行的现象
Error：系统级异常
StackOverflowError 栈溢出
OutOfMemoryError 内存溢出
InterruptedException 线程
…
Exception
CompileException:编译异常
流
线程
Java连接操作数据库
RuntimeException：运行时异常
InputMismatchException
ArrayIndexOutOfBoundsException
ArithmeticException
ClassCastException
NumberFormatException
…
//异常处理方式
//非编译异常：推荐使用程序逻辑规避异常的发生
//比如：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©) {
return false;
}
}
return true;
}
//比如：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;
}

	//编译异常：走异常的常规套路
	处理方式1：（快捷方式  .try）
	try{
		//可能出现的代码段
		xxx...
		xxx...
		xxx...
	}catch(XxxException1 e){	//catch的数量取决于代码段中可能产生异常的种类数
								//如果不同种类的异常，必须不同处理，则必须多个catch
								//即使存在多个不同种类异常，但处理方式相同，则一个catch即可（多态的方式，父类）
	}catch(XxxException2 e){
		
	}catch(XxxException3 e){
		
	}
	xxx...
	
	处理方式2：抛出异常
	public xxx method(xxx xxx) throws xxxException{//如果选择抛出异常：必须为编译异常（Exception）
		//系统预定义异常：自动抛出
		//自定义异常：必须手动抛出
		throws new XxxException("...");
	}
	//自定义异常：public class XxxException extends Exception/RunTimeException{...}

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

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

//举例说明：
public interface Info{
	public int add(int a,int b);
	public int add(int...as);
}

public class InfoFactory{
	public static Info get(){
		return new Info(){
			@override
			public int add(int a,int b){
				return a+b;
			}
			@override
			public int add(int...as){
				int sum = 0;
				for(int a:as){
					sum = add(sum,a);
				}
				return sum;
			}
		};
	}
}

//测试类
public class CollectTest {
	public static void main(String[] args){
		Info info = InfoFactory.get();
		system.out.println(info.add(a:1,b:2));
		int[] as = {1,2,3};
		system.out.println(info.add(as)));
	}
}

//对象之间的等值比较
objOne.equals(objTwo)
//默认是比较地址
public boolean equals(){
return(this==obj);
}
//可以通过重构equals,修改比较的规则
public class User{
private String username;
private String password;
public User(String username,String password){
this.username = username;
this.password = password;
}

@Override
public boolean equals(Object obj){
	return null !=obj 
			&& obj instanceof User
			&&((User)obj).username.equals(this.username)
			&&((User)obj).password.equals(this.password);
	}
	
}

//对象之间比较大小
//实现Comparable
public class User implements Comparable{
private String username;
private String password;
private int age;

public User(String username,int age){
	this.username = username;
	this.age = age;
	
}

/**
*	@param o
*	@return 1: this>o 0: this==o -1: this<o
*/
@Override
public int compareTo(User o){
	return null ==o?-1:this.age>o.age? 1:this.age==o.age?0:-1;
}

}

//