Java_基础1

面向过程：适合简单，不需要协作的事务。
面向对象：宏观上使用面向对象把握，微观上处理任然是面向过程。

Java虚拟机的内存可以分为三个区域： 栈Stack，堆heap，方法区method area
　　栈的特点：方法执行的内存模型，每个方法被调用都会创建一个栈帧（储存局部变量，操作数，方法出口等）；
　　　　JVM为每个线程创建一个独立的栈，用于存放该线程执行方法的信息；
　　　　栈属于线程私有，不能实现线程间的共享；
　　　　栈是由系统自动分配，速度快，栈是一个连续的内存空间。
　　堆的特点
　　　　用于存储创建好的对象和数组；
　　　　JVM只有一个堆，被所有线程共享；
　　　　堆是一个不连续的内存空间，分配灵活，速度慢；
　　方法区：
　　　　实际也是堆，只是用于储存类，常量相关的信息；


构造器：
　　通过new关键字调用；
　　构造器虽然有返回值，但是不能定义返回值类型，不能再构造器里使用return返回某个值
　　如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。
　　构造器的方法名必须和类名一致。

垃圾回收机制：
　　发现无用的对象；
　　回收无用对象占用的空间；
　　两个方法： 引用计算法+引用可达法；
　　通用的垃圾回收机制：
　　　　年轻代：Eden
　　　　年老代：Tenured
　　　　持久代：Perm

对象创建的过程和this的本质：
创建对象：
1. 分配对象空间，并将对象成员变量初始化为0或空
2. 执行属性值的显式初始化；
3. 执行构造方法；
4. 返回对象的地址给相关的变量；
this的本质就是”创建好的对象的地址“；
1.this不能用于static方法中；
2. 在程序产生二义性之处，应使用this来指明当前对象，普通方法中，this总是指向调用该方法的对象。

Static关键字：静态的
类变量的生命周期和类相同。
static修饰的成员变量和方法，从属于类。 普通变量和方法从属于对象。

Java参数传值机制：
传递的是值的副本，所以传值不会影响原参数。

Java的包package机制：
　　包对于类，就相当于文件夹对于文件的作用。
　　包名：域名倒着写即可，再加上模块名，便于内部管理内。
　　写项目有时要加包，不要使用默认包。

继承，封装，多态：
　　java只有单继承；

方法的重写：
子类重写父类的方法：

方法的重载：
　　就是不同的方法，但是名称相同。
　　方法名相同，参数不同，构成重载；参数类型不同，构成重载；参数顺序不同，构成重载；
　　只有 返回值不同，不构成重载；只有参数名称不同，不构成重载。

package Packagetest;

public class ExtendTest {
    public static void main(String[]args){
        Student stu=new Student();
        stu.name="spencer";
        stu.height=185;
        stu.major="logistics";
        stu.rest();
        
        Student stu2=new Student("alex",20,"coder");
        System.out.println(stu2 instanceof Student);
    }
}

class person{
    String name;
    int height;
    
    public void rest() {
        System.out.println("人类");
    }
}

class Student extends person{
    String major;
    
    public void study(){
        System.out.println("学习");
    }


    public Student(String name,int height,String major) {
        this.name =name;
        this.height=height;
        this.major=major;
    }
    
    public Student() {
        
    }
}

递归： 自己调用自己
　　1. 定义递归头：如果没有这个就会进入死循环。
　　2. 定义递归体：什么时候需要调用自身方法。

　　Object类中定义有Public String toString()方法，其返回值是String类型。
　　Object类中定义有：Public boolean equals(object obj)方法，提供定义“对象内容相等”的逻辑。
　　在eclipse中右键souce，可以自动重写；

package Packagetest;

public class ObjectTest {
    public static void main(String[]args) {
    //    Object obj;
        ObjectTest to =new ObjectTest();
        System.out.println(to.toString());
        
        Person01 p1=new Person01("spencer",28);
        System.out.println(p1.toString());
    }
     public String toString() {
         return "object 测试";
     }
}

class Person01{
    String name;
    int age;
    
    @Override
    public String toString() {
        return name+ "年龄" +age;
        
    }
    public Person01(String name,int age){
        this.name = name;
        this.age=age;
    }
}

Super关键字
　　是直接父类对象的引用， 可以通过super访问父类中被子类覆盖的方法或属性；

package Packagetest;

public class SuperTest {
    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(); //调用父类对象的普通方法，如果直接使用，f（）是子类的value，加super是父类的value
        value=101;
        System.out.println("childclass.value="+value);
        System.out.println(value);
        System.out.println(super.value);//调用父类对象的成员变量
    }
}

package Packagetest;

public class SuperTest02 {
    public static void main(String[]args) {
        System.out.println("开始创建一个childclass对象");
        new ChildClass1();
    }
}

class FatherClass1{
    public FatherClass1() {
        System.out.println("创建fatherclass");
        
    }
}

class ChildClass1 extends FatherClass1{
    public ChildClass1() {
        //super(); super会自动创建
        System.out.println("创建childclass");
    }
}

静态初始化：
　　1. 先上溯到object类，先执行object的静态初始化模块，再向下执行之类的静态初始化块，直到类的静态初始化模块为止。
　　2. 同样的，构造方法执行顺序和上面的顺序一样。 构造方法的第一句总是super（）；

封装：
　　private:只有自己类能访问；
　　default：只有同一个包的类能访问；
　　protected：可以被同一个包的类以及其他包中的子类访问；
　　public：可以被改项目在所有包中的所有类访问；

类的属性的处理：
　　1. 一般使用private，int，String，boolean等，外部必须要通过set方法和get方法来设置；

多态： 同一个方法的调用，对象的不同，会产生不同的行为。
　　1. 方法的多态，而不是属性的多态，属性没有多态；
　　2. 三个必要条件：继承，方法重写，父类引用指向子类对象；
　　3. 父类引用指向子类对象；


final关键字：
　　1. 修饰常量，不能更改；
　　2. 修饰方法，不能重写，但可以重载；
　　3. 修饰类，子类不能继承。

数组：相同类型数据的有序集合。
　　1.数组的声明：type[] 变量名；string[] arr02; 分配空间：int[] arr01= new int[10];
　　2. 数组的初始化：静态，动态和默认三种方式；
　　3.数组的遍历：for each循环==>读取数组或集合中的所有元素；

package Packagetest;

public class EqualsTest {
    public static void main(String[]args) {
        
        User u1 = new User(12345,"spencer","xxxx");
        User u2 = new User(23456,"alex","ccccc");
        //用id判断是否是同一人
        System.out.println(u1==u2);
        System.out.println(u1.equals(u2));
    }
}


class User{
    int id;
    String name;
    String pwd;
    
    public User(int id, String name, String pwd) {
        super();
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    //右键souce自动生成，string类也可以；
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (id != other.id)
            return false;
        return true;
    }
}