数组
- 相同的数据类型的数据集合
- 按照一定的先后次序排列组合
- 通过下标来访问他们
声明---创建
- 建议 String[] a;
- String a [];//c 和c++才有不专业
String [] a =new int [10];
a[i]--取值
数组的默认初始化
- 数组是引用类型,他的元素相当于类的实例变量,因此数组一经过分配空间,其中的每个元素也按照实例变量同样的方式被隐藏初始化
- 静态初始化::栈
- 动态初始化::栈和堆
基本特点:
- 数组的长度是确定的
- 元素必须是相同的类型
- 数组的元素可以是任何的数据类型
- 数组变量属于引用类型
- 数组本身是对象,java的对象是在堆中的,数组对象是在堆中的
- 下标的合法区间[0,n-1]
- 数组也是对象,数组的元素属于成员变量
- 数组的长度是确定的,不可变,不能越界
数组的使用:
int[] a ={1,2,3,4,5};
//打印全部的数组元素
for(int i-0;i<a.length;i++){
syso.(a[i]);
}
//计算所有元素的和
int sun=0;
for(int i-0;i<a.length;i++){
//sum=sun+a[i]
sun+=a[i];
}
//查找最大值
int max=arry[0];
for(int i-1;i<a.length;i++){
if(array[i]>max){
max=array[i];
}
}
//增强的for循环 但是取不到下标
for(int array :a){
syso(a);
}
//反转数组
int[] result new int[a.length];
for(int i-1;j<result.length;i<a.length;i++;j--){
result[j]=a[i];
}
多维数组:
int[][] a={{1,2,3},{1,2,3},{1,2,3}};
遍历
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
syso.(a[i[j]]);
}
}
对象Arrays
java.util.arrays
int[] a ={1,2,3,4,5};
static修饰可以直接用
- 打印数组的元素
Arrays.toString(a);
- 排序
Arrays.sort(a);//升序
- 赋值
fill方法
Arrays.fill(a,0);
- 比较
比较equals方法 //比较数组的元素是否相等
- 查找
binarySearch能对排序好的查找进行二分查找
稀疏数组
- 记录数组一共有几行几列,有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小的规模的数组中,从而缩小小程序的规模
int[][] array =new int[11][11];
array[1][5]=10;
array[5][5]=5;
//获得有效值的个数
int sum =0;
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;i++){
if(array[i][j]!=0){
sum++;
}
}
}
//创建稀疏数组
int [][]array2 =new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍历二位数组,将非零的值存放在数组中
int count =0;
for(int i=0;i<array.length;i++){
fro(int j =0;j<array[i].length;j++){
if(array[i][j]!=0){
count++;
array2[count][0]=i;
array2[count][1]=j;
array2[count][2]=array[i][j];
}
}
}
八种排序算法
- 冒泡排序 O(n2)
for(int i=0;i<array.length-1;i++){
for(int j=0;j<array.length-i;j++){
if(array[j+1]>array[j]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
- 选择排序
for(int i =0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int tem = arr[i];
arr[i]=arr[j];
arr[j]=tem;
}
}
}
- 二分查找(前提是拍好序列)
内存分析
堆
- new的对象
- 数组
- 可以被所有的线程所共享的,不会存放别的对象的引用
栈
- 存放基本的变量类型
- 引用的对象的变量
方法区
- 可以被所有的线程共享
- 包含了所有的clss和static变量
面向对象编程
oop
对于描述复杂的事物,为了从宏观上把握,从整体上合理的分析,我们需要使用面向对象的思想来分析整个系统。但是在微观操作上,仍然需要面向过程的思想去处理
本质:已类的方式组织代码,已对象的组织(封装数据)
特征:
- 封装
- 继承
- 多态
方法的调用、值传递、类和对象的关系
类是一种抽象的数据类型,但是不能表示一种具体的事物
对象是抽象的概念的具体实例
new 创建对象
类:
- 属性
- 方法
抽象的类要实例化
构造方法:
- 必须和类的名字相同
- 必须没有返回值
new的内存分析:
。。。。
封装:
- 属性私有,get/set
高内聚,低耦合
继承
java类中只有单继承,没有多继承
extends
- 继承是类和类之间的关系,类之间的关系好友依赖,组合,聚合
- 继承是两个类的关系 源生类 派生类
- 子类和父类之间有is a关系
- Object
- super
- 方法的重写
Super方法
super.父类的方法直接写就行了
this当前类的
调用构造器只能在第一行
默认调用父类的构造器
如果父类没有无参的构造,子类也无法写无参的构造
子类的代码会隐藏父类的无参的构造
注意:
- super调用父类的构造方法,必须在构造方法的第一个
- super必需只能出现在子类的方法或者构造方法中
- super和this不能同时使用
前提:
- this本身调用者这个对象
- super:代表父类对象的应用
构造方法:
- this()本身的构造
- super父类的构造
重写@Override
- 非静态的
- 私有的不行
- 方法名必须相同
- 参数列表相同
- 修饰符可以扩大
- 重写可能会抛出异常,异常可以缩小不能扩大
public》protected》Default》private
多态
动态编译
interface implements
存在的条件:
- 有继承关系
- 子类重写父类的方法
- 父类的引用指向子类对象
父类的应用指向子类
B b =new A();
class A extends B;
注意事项:
- 多态是方法的多态,属性没有多态
- 父类和子类,有联系 类型转换异常ClassCastException
- 存在条件。。。。。前面有
方法要被重写--多态:
不能重写的
- static属于类,不属于实例
- final 修饰的无法 在常量池内
- private修饰的
instanceof 判断一个数据的类型
x instanceof y;
x和y之间是否有父子关系
类型转换,子类的方法要类型转换。
子类----父类 ---向上转型
父类---子类------强制转换
Static
private static int a;//多线程
private int b;
静态变量在一个特别的区里面;
public static run(){
}
public go(){
}
- 静态方法只能静态方法
- 静态方法随着类加载生成
- 可以直接使用(静态代码块)
静态代码块static{}------匿名代码块{}-----构造方法
静态导入包
import static java.lang.PI;
被final定义的类不能被继承----断子绝孙
抽象类
abstract:
抽象类的子类要实现抽象类的所有的方法;
extends
但是是单继承
- 不能new抽象类,只能那子类去实现它:约束
- 抽象类里面可以放普通方法
- 抽象方法必须放在抽象类里面
接口
interface implements
- 只有规范,面向接口编程
接口的本质是契约
接口的方法都是public abstratact 的
- 类实现接口必学实现接口中的方法
- 接口里面的变量是常量public static final
接口不能实例化,没有构造方法
内部类
- 成员内部类
- 静态内部类
- 局部变量
- 匿名内部类
public Class outer{
private int id;
public void out(){
syso(“外部类”)
}
//内部类可以获得外部类的私有属性和方法
public class Inner{
public void in(){
syso("内部类");
}
}
}
//内部类
Outer out =new Outer();
Outer.Innter inner= out.new Inner();
静态内部类:
public Class outer{
private int id;
public void out(){
syso(“外部类”)
}
//内部类可以获得外部类的私有属性和方法
public static class Inner{
public void in(){
syso("内部类");
//这里就拿不到外部类的变量的值了,静态内部类无法访问静态方法
}
}
}
局部内部类:
在方法里面写内部类:
public Class outer{
private int id;
public void out(){
syso(“外部类”)
public class Inner{
public void in(){
syso("内部类");
}
}
}
}
一个java里面可以写多个class类
class a{}
class b{}
匿名内部类:
接口 a = new 接口(){
@Override
方法
}
Error和Exception
- 异常是指运行中出现不预期的各种状况
- 异常发生在程序运行期间,他影响了正常的执行流程
异常分为:
- 检查性异常
- 运行时异常
- 错误Error
java.lang.Throwable 超类
- ArrayLndexOutOfBoundsException 数组线标越界
- NullPointerExceotion空指针异常
- ArithmeticException算数异常
- MissingResourceException 丢失资源
- ClassNotFountException找不到类等异常
抛出异常:
捕获异常
关键字:
try catch finally throw throws
throw new ArithmeticException();//抛出一个异常
//一般在方法中使用,加入这个方法处理不了这个异常,就抛出异常
public void a throws ....
自定义异常
public ex extends Exception{
//传递数字》10
private int detail;
public ex (int a){
this.detail = a;
}
@Override
public String toString(){
return "myex{"+detail+"}";
}
}
throw new ex();