方法、类、对象、数组基本知识

方法

方法的重载：即方法名相同，方法列表中的参数类型、参数个数不同；与方法的返回值无关。例如：

public int add(int a,int b){}  //方法一
public int add(int a,int b,int c){}  //方法二
public int add(int a,double b){}  //方法三
public int add(double a,int b){}  //方法四
public double add(int a,int b){}  //方法五
//方法一、二、三、四互相构成方法的重载，方法五与方法一、二、三、四不构成方法重载

//%d表示一个常数，%s表示传入一个值，%n表示换行
System.out.println("%d阶乘的结果：%s%n",10,factorial(10));   

类和对象

OOA：面向过程分析；

OOD：面向过程设计；

面向过程适合简单，不需要协作的事务；

面向对象适合比较复杂，需要协作的事务；

面向对象和面向过程的总结：

1. 都是解决问题的思维方式，都是代码组织的方式；
2. 解决简单问题可以使用面向过程；
3. 解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程；

类：我们称为class；对象：我们叫做object、instance(实例)。

类中只有属性没有方法的叫做结构体；类中既有属性又有方法的叫做对象。

Java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area。

栈的特点：

• 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈顶(存储局部变量、操作数、方法出口等)。
• JVM为每个线程创建一个栈，用于存放该线程执行方法发的信息(实际参数、局部变量等)。
• 栈属于线程私有，不能实现线程间的共享！
• 栈的存储特性是“先进后出，后进先出”。
• 栈是由系统自动分配，速度快！栈是一个连续的内存空间！

堆的特点：

• 堆用于存储创建好的对象和数组(数组也是对象)。
• JVM只有一个堆，被所有线程共享。
• 堆是一个不连续的内存空间，分配灵活，速度慢！

方法区的特点：

• JVM只有一个方法区，被所有线程共享！
• 方法区实际也是堆，只是用于存储类、常量相关的信息！
• 用来存放程序中永远是不变或唯一的内容(类信息【Class对象】、静态变量、字符串常量等)。
• 用于存储代码、静态方法、静态变量、字符串常量。

构造方法：

public class Student{
	int id;
	String name;
    public Student(int id,String name){
        this.id=id;   //这里的this表示成员变量中的id
        this.name=name;
        //如果这里将this去掉这里的id表示的还是局部变量的id,即
        /*
        id=id；//表示的局部变量中的id
        */
    }
}

要想在一个构造器中调用另一个构造器方法，可以使用this这个关键字，例如：

public class TestThis{
    int a,b,c;
    static String company;
    static{   //静态语句块
        System.out.println("Helloworld");
        company="上海";
    }
    TestThis(int a,int b){
        this.a=a;
        this.b=b;
    }
    TestThis(int a,int b,int c){
       /* this.a=a;
       * this.b=b;
       */             //这两种方式等价
       this(a,b);    //采用这种方法写的话this(a,b)必须位于构造方法的第一句
       this.c=c;
    }
}

注意：this不能用于static方法，静态方法中不可以调用非静态方法和非静态变量，但是非静态方法中可以调用静态方法、以及使用静态变量。

方法的重载：overload；

方法的重写：override；

object类中的toString()方法:

public String toString() {   //返回该对象的所在的位置(包名.类名 @ 该对象的hashcode)
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

"=="与equal的区别：

**”==“**代表 比较双方是否相同 ，如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

”equal“如果没有重写该方法，则系统默认的比较两个对象的hashcode是否相同(地址)，没有重写的equal方法如下：

public boolean equals(Object obj) {
        return (this == obj);   //比较两个对象之间的地址是否相同
    }

所以一般要比较两个对象是否属于属于同一对象以及两个对象的内容是否相同，可以通过重写Object中的equal方法

super关键字：在子类中可以通过super这个关键字调用父类中的普通方法，例如：

public class Test {
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass{
    public int value;
    public void f(){
        value=100;
        System.out.println("FatherClass.value="+value);
    }
}
class ChildClass extends FatherClass{
    public int value;
    public void f(){
        super.f();   //调用父类对象的普通方法
        value=200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value);  //调用父类对象中的成员变量
    }
}

输出结果:
FatherClass.value=100
ChildClass.value=200
200
100

super在构造方法中的用途：当子类中的构造方法中默认有super()这个方法，写与不写都是一样的，这个是系统默认有的，表示每次执行子类的构造方法是首先要先执行父类的构造方法，例如：

public class Test02 {
    public static void main(String[] args) {
        System.out.println("开始执行：");
        new ChildClass02();

    }
}
class FatherClass02{
    public FatherClass02(){
        System.out.println("我是FatherClass");
    }
}
class ChildClass02 extends FatherClass02{
    public ChildClass02(){
       //super();  
       //加不加super()执行的结果都是一样的
        System.out.println("我是ChildClass");
    }
}

输出结果：
            开始执行：
            我是FatherClass
            我是ChildClass

封装

在设计程序的时候，程序员一般追求的是“高内聚，低耦合”。

编程中封装的优点:

1. 提高代码的安全性；
2. 提高代码的复用性；
3. “高内聚”:封装细节，便于修改内部代码，提高可维护性。
4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

封装的实现：通过访问修饰符来实现封装。

private：只能在同一个类中可以使用，不同类中是不可以使用，包括其子类，虽然子类继承了父类的该属性，但是子类无权限使用该属性；

default：即系统默认的，使用该修饰符的属性只能在该类或者该包中使用，超过该包中不能使用；

protected：使用该修饰符的属性只能在该类中、该包中、以及不同包下其子类当中使用；

public：即公开的；

修饰符	同一个类	同一个包中	不同包的子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

一般将类中的属性以及方法进行封装，如果将类中的属性进行封装的话，外部类要想使用该属性时，可以通过调用该类中的set和get方法。

多态

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。

多态的要点：

1. 多态是方法的多态，不是属性的多态(多态与属性无关)；
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象；
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了；

数组：

数组的三个基本特点：

1. 长度是确定的，数组一旦被创建，它的大小就是不可以改变的；
2. 其元素必须是相同类型，不允许出现混合类型；
3. 数组类型可以是任何数据类型，包括基本类型和引用类型；

数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组的初始化方式：

1. 静态初始化；(int [] a={1,2,3,4};如果{}中为空时，则表示该数组长度为0，即数组中没有元素)；
2. 动态初始化(int [] a=new int[3];a[0]=1;a[1]=2;a[2]=3)；
3. 默认初始化(int [] a=new int[3])；

数组中的遍历方式：

• for循环遍历，( for( ; ; ) )
• forearch循环遍历，即for( : )遍历，也叫增强for

 public static void main(String[] args) {
 int []a={1,3,4,5,6};
 for (int m:a) {
            System.out.println(m);
        }
 }