面向过程和面向对象的区别

• 面向过程:要求的是做每件事的具体步骤 例如 得到两个数的和 第一步就是定义两个数的数据类型，第二步就是将两个数相加得到和，最后一步就是返回和。这三步就是实现得到两个数的和的功能他是面向过程编程的。
• 面向对象:要求的是每件事是由谁来做,具体的步骤是封装起来的不需具体了 解 例如得到一个数的绝对值 只需要用Math这个静态的对象调用abs方法即可,无需知道他里面是如何得到这个数的绝对值。

面向对象的主线

• 1.特点:封装，继承，多态
• 2.类结构和对象内存
• 3.关键字

类和对象

• 类:类是所有对象的模板，通过这个模板可以创建不同的对象。例如 学校提供参考的简历模板就是一个类，这个模板他有简历都应该有的东西，通过同学将自己的个人信息填上去就是一个对象。
• 对象:对象就是由模板具体化出来的，例如同学将自己的信息填在了个人简历模板上就是一个具体的对象，因为每个同学的信息千差万别所以一个模板(类)可以创建出无数个具体的对象。所以说设计好类是面向对象编程的重点。

行为和属性

• 行为(方法):行为从表面上就是一个对象(类)可以做的事情。例如：Math中的abs，min,max就是这个对象(类)的方法，他可以进行加减乘除。行为的组成包括修饰符，返回值，方法名，形参列表(可有可无)

 public static void main(String... args)

 public static int abs(int a) {
        return (a < 0) ? -a : a;
    }

• 属性:用来描述一个类或对象当前的状态或者是应当被赋予的东西。例如:人这个类或对象就会有姓名，年龄，性别的属性。这些属性就是一个人类应当与生俱来的东西。属性的组成包括修饰符，数据类型，属性名，字面值(可有可无)

 public static final double PI = 3.14159265358979323846;

属性和局部变量的区别 有无修饰符，定义的范围不同，存在的空间不同，是否初始化

• 属性 :定义在类中，先声明后使用，存在于堆空间中，有修饰符修饰，有数据类型和变量名，默认初始化。
• 局部变量:定义在方法的形参，构造器的形参，方法体中，构造器中，代码块中，先声明后使用，存在于栈空间中，无修饰符修饰，有数据类型和变量名，手动赋值。

return关键字

• 1.用于结束一个方法
• 2.为方法返回一个结果值

对象数组

        Student[] students = new Student[5];
        for (Student student : students) {
            System.out.print(student + "\t");
        }
        System.out.println();
        students[0] = new Student();
        students[1] = new Student();
        students[2] = new Student();
        students[3] = new Student();
        students[4] = new Student();
        for (Student student : students) {
            System.out.print(student + "\t");
        }

null    null    null    null    null    
com.pojo.Student@5d6f64b1   com.pojo.Student@32a1bec0   com.pojo.Student@22927a81   com.pojo.Student@78e03bb5   com.pojo.Student@5e8c92f4

• 引用数据类型只存储两种值：null或者地址值

匿名对象

    public void eat()
    {
         System.out.println(this);
    }
    public void sleep()
    {
         System.out.println(this);
    }

 new Student().eat();//com.pojo.Student@5d6f64b1
 new Student().sleep();//com.pojo.Student@32a1bec0

• 匿名对象就是没有变量名的对象
• 一个对象只能操作一次属性或方法，使用一次后就不可以使用了
• 使用匿名对象的常规方法

public class Builder {
    public void create(Student student)
    {
        student.eat();
        student.sleep();
    }
}
new Builder().create(new Student());

com.pojo.Student@5d6f64b1
com.pojo.Student@32a1bec0

com.pojo.Student@22927a81
com.pojo.Student@22927a81

重载overLoad

• 定义:在同一个类中，允许存在一个以上的同名方法，只要方法的参数个数或参数类型不同或参数的位置不同即可
• 跟方法的修饰符，返回类型，形参变量名，方法体没关系
• 判断是否构成重载:同一个类，同个方法名，不同的参数个数，不同的参数类型，不同的参数位置

值传递

• 1.基本数据类型
  赋值的是变量所保存的数值

public static void main(String[] args)
    {
        int m=10;
        int n=20;
        swap(m,n);
        System.out.println(m+"\t"+n);
    }

    public static void swap(int m,int n)
    {
        int temp=m;
        m=n;
        n=temp;
        System.out.println(m+"\t"+n);
    }

• 2.引用数据类型
  赋值的是变量所保存的地址值

  public static void main(String[] args) {
        /*int m=10;
        int n=20;
        swap(m,n);
        System.out.println(m+"\t"+n);*/

        Data data = new Data();
        data.m = 10;
        data.n = 20;
        swap(data);
        System.out.println(data.m + "\t" + data.n);
    }

    public static void swap(Data data) {
        /*int temp=m;
        m=n;
        n=temp;
        System.out.println(m+"\t"+n);*/

        int temp = data.m;
        data.m = data.n;
        data.n = temp;
        System.out.println(data.m + "\t" + data.n);
    }

}

class Data {
    int m;
    int n;
}

可变个数参数Varargs机制

• 定义:允许定义和多个实参相匹配的形参，用更简单的方法传递个数可变的实参
• 当调用可变个数参数的方法时可以传递0个或0个以上的实参
• 可变个数形参方法和同类中同名方法构成重载但是优先考虑具体类型的形参方法
• 可变个数形参方法和同类中同名的同类型数组形参不能定义在一起

public class Person {

    public void show(String... strings)
    {

    }

    /*public void show(String[] strings)
    {

    }*/
}

• 可变个数形参方法的遍历和数组形参遍历一样

public void show(String... strings)
    {
       for(String string:strings)
       {
           System.out.println(string);
       }
    }

• 方法中的可变个数形参必须声明在末尾Vararg parameter must be the last in the list

 public void show(int i,String... strings)
    {
       for(String string:strings)
       {
           System.out.println(string);
       }
    }

• 在方法中只能声明一个可变个数形参

封装性

• 隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性，可维护性，通俗的说，把该隐藏的隐藏起来，把暴露的暴露出来。

• 体现:
  成员属性的私有化，提供公共的Settter,getter方法
  成员方法的私有化
  构造方法的私有化 单例模式

权限修饰符

• public:(公共权限)

可以修饰类,成员变量,成员方法,构造方法
被public修饰的成员,可以在任何一个类中被调用,不管同包或不同包,是权限最大的一个修饰符

• protected:(受保护权限)

可以修饰成员变量,成员方法,构造方法,不能修饰类(外部类,内部类不考虑)
如果有不同包的类想调用它们,那么这个类必须是定义它们的类的子类。

• default(默认权限)

类,成员变量,成员方法,构造方法都能使用默认权限,即不写任何关键字
默认权限即同包权限,同包权限的元素只能在定义它们的类中使用,以及同包的类中被调用

• private:(私有权限)

可以修饰成员变量,构造方法,成员方法,不能修饰类(外部类,内部类不考虑)
被private修饰的成员,只能在定义它们的类中使用,在其他类中不能调用。

• 并不是每个修饰符都可以修饰类(指外部类),只有public和default可以
• 所有权限修饰符都可以修饰数据成员,方法成员,构造方法
• 为了代码安全起见,修饰符不要尽量使用权限大的,而是适用即可。比如,成员变量,如果没有特殊需要,尽可能用private

构造器

• 作用:用于创建对象 new + 构造器和对对象属性进行初始化
• 如果没有显式定义构造器，系统会默认提供一个空参构造器
• 定义:权限修饰符 类名(形参列表) {}
• 一个类中多个构造器彼此构成重载
• 一旦显示定义构造器系统就不会提供默认的无参构造器
• 一个类中至少有一个无参构造器

this关键字

• this表示当前对象或当前正在创建的对象，可以调用属性，方法，构造器

• 在类的方法中，使用this.方法()或this.属性,表示调用当前对象的属性或方法，但是通常省略。如果方法中形参和成员属性同名时，必须显示的使用this来区别成员属性和局部变量

• 在类的构造器中，使用this.方法()或this.属性,表示调用当前正在创建的对象的属性或方法，但是通常省略。如果构造器中形参和成员属性同名时，必须显示的使用this来区别成员属性和局部变量

• this调用关键字 可以使用this(形参列表)调用本类中其他的构造器，但是不可以通过this.(形参列表)自己调用自己，而且最终只初始化了一个对象

• 如果一个类中有n个构造最多只有n-1使用了this关键字调用构造器

• this.(形参列表)要放在构造的首行即同一个构造器不能有两个this.(形参列表)

 public class Animal {
    

    private String name;
    private int age;


    public Animal()
    {
        System.out.println("初始化信息");
    }


    public Animal(String name) {
        this();
        this.name = name;
    }

    public Animal(String name,int age)
    {
        this(name);
        this.age=age;
    }
}

package关键字

• 为了更好的管理项目中的类，提出了package关键字

• package放在源文件的首行

• 创建包需要符合命名规范 xxx.xxx.xxx,每"."一次代表一层文件目录

• 同一个包下，不可以命名同一个类和接口，不同包下可以命名同一个类和接口

import关键字

• 在源文件中显式的调用import结构导入指定的包下的接口和类，声明package包和class之间

• 如果需要导入多个结构，可以并列的写出来或者是用占位符* 。如import java.util.Map.*;

• 如果使用java.lang.*下的类和接口可以不用使用import结构，在同一个包中调用类和接口也不用使用import结构

• 如果在源文件中使用了不同包中的同名类，必须有一个类使用全类名来表示

• 使用import导入xxx.下所有结构，但是其xxx包下的子包任需要导入。如import java.lang.reflect.;

• 使用import static 可以导入指定的类和接口的静态结构。如import static java.lang.System.*;