JAVA学习笔记-04

1.面对对象

1.1 抽象类：包含抽象方法的类，不能实例化

public abstract class Animal{
    public abstract void run();
    public void breath(){//可以包含普通方法
        System.out.println("呼吸");
    }
}

public class Cat extends Animal{
    @override
    public void run(){//子类必须重写父类抽象方法
        System.out.println("猫步");
    }
}

1.2接口

---

• 比抽象类还要抽象，不能包含普通方法
  给设计师写的

public interface Animal{//接口中只有：常量，抽象方法
    String MAX_GRADE="100";//(public static final)默认在前面
    int MAX_SPEED=120;
    void run();//(public abstract)默认在前面
    int age(int a,int b);   
}

public class Dog implements Animal{//一个类可以实现多个接口
    @override
    public void run(){
        System.out.println("狗跑"+MAX_SPEED);
    }
    @override
    public int age(int a,int b){
        return a+b;
    }
}

注：一个人只有一个父亲，但是可以遵守多个规范

1.4内部类
内部类：把一个类，放到另一个类的内部定义实现，提供更好的封装。
外部类可以直接访问，但是其他类不能直接访问。
内部类可以直接访问外部类的私有属性，但是外部类不能直接访问内部类的属性。

public class Face{
    String faceType;
    class Nose{//内部类
        String noseType;
        void breath();
    }
}

public class Test{
    public static void main(String[] args){
        Face.Nose nose =new Face().new Nose();
        //两种调用方法
        Face f= new Face();
        Nose n = f.new Nose();
    }
}

静态内部类，

2.数组

数组也是对象，引用类型。

int[] a = new int[3];//对象
a[0]=21;
a[1]=22;
a[2]=23;
Car[] c = new Car[10];
c[0]=new Car("benzi");//类数组
c[1]=new Car("BMW");

public class Car{
    String name;
    public Car(String name){
        this.name=name;
    }
} 

• 三种初始化方法

int[] a;
int b[];//声明
a = new int[4];//创建
b = new int[5];//
//默认初始化,数组元素相当于对象的成员变量，默认值也一样
//动态初始化
for(int i=0;i<a.length;i++){
    a[i]=i*12;
}
//静态初始化
int c[]={23,24,25};
Car[] c1 = {new Car("benzi"),new Car("BMW")};

3.String

• String：不可变字符

boolean equals(Obeject a)//字符串相等，返回true


3.1StringBuilder
　String：字符串常量
　StringBuffer：字符串变量，有一段16字符的Buffer，不够再扩容。安全
　StringBuilder：字符串变量，不安全

1 String s = "abcd";
2 s = s+1;//不断创建新的对象，JVM回收垃圾
3 System.out.print(s);

3.2模拟ArrayList代码

public class MyArrayList {
    private Object[] value;
    private int size;

    public MyArrayList() {
        this(16);//调用下面的构造器
    }//初始化

    public MyArrayList(int size) {
        value = new Object[size];
    }//初始指定长度

    public void add(Object obj) {
        value[size]=obj;
        size++; 
        if(size>=value.length) {
            Object[] newValue=new Object[value.length*2];
            for (int i=0;i<value.length;i++) {
                newValue[i]=value[i];
            }//拷贝原始数据
            value=newValue;
        }
    }//添加对象

    public Object get(int index) {

        if(index<0||index>size-1) {
            try {
                throw new Exception();
            }catch(Exception e) {
                e.printStackTrace();

            }
        }
            return value[index];
    }//获取当前index对象

    public int Size() {
        return size;
    }//返回大小

    public int indexOf(Object obj) {
        if(obj==null) {
            return -1;
        }else {
            for(int i =0;i<value.length;i++) {
                if(value[i]==obj) {
                    return i;
                }
            }
        }
        return -1;//找不到
    }//返回对象的index

    public int lastIndexOf(Object obj) {
        if(obj==null) {
            return -1;
        }else {
            for(int i=value.length-1;i>=0;i--) {
                if(value[i]==obj) {
                    return i;
                }
            }
        }
        return -1;//找不到
    }   
}

public class Human {
    String name;
    public Human(String name) {
        this.name=name;
    }
}

public class Human {
    String name;
    public Human(String name) {
        this.name=name;
    }
}