了解Java

一.类和对象的基本概念

在Java中一切皆对象，一切都围绕对象进行，找对象、建对象，用对象等
类：把具有相同属性和行为的一类对象抽象为类。类是抽象概念，如人类、犬类等，无法具体到每个实体。
对象：某个类的一个实体，当有了对象后，这些属性便有了属性值，行为也就有了相应的意义。
类是描述某一对象的统称，对象是这个类的一个实例而已。有类之后就能根据这个类来产生具体的对象。一类对象所具备的共同属性和行为（方法）都在类中定义。

二.类和对象的定义和用法

2.1 如何创建类

class 类名称 {
 
成员变量/ 实例变量；
 
成员方法；
 
}

2.2 创建具体的对象

类名称 引用名称 = new 类名称（）

例如：Person per = new Person();

这个对象的引用 对象（在堆中储存）

（相当于给对象起了个名字）（所有类的对象都是引用数据类型）

2.3 实例

public class demo1{
    public static void main(String[] args) {
        //创建一个实例化对象
        Person person1= new Person();
        //通过对象来调用实例变量、成员方法
        person1.name = "小韩";
        person1.age = 18;
        person1.sex = "女";
        person1.print();
        Person person2= new Person();
        person2.print();
    }
}
class Person{
    //成员变量（实例变量)，在堆中的每个对象中存储，通过对象调用
    String name;
    int age;
    String sex;
    //成员方法（实例方法），在JVM的方法区中存储，通过对象调用
    void eat(String food){
        System.out.println(name+"正在吃"+food);
    }
    void print(){
        System.out.println("name:"+name+", age:"+age+", sex:"+sex);
    }
}

输出结果如下：

三.static关键字

3.1 static修饰属性（类属性、类变量）

1.当一个实例变量被static关键字修饰后，它就表示类的属性，该类的所有对象共享此属性，且对象的属性值相同。static修饰的属性在JVM的方法区中存储。

2.static修饰的属性，直接通过类名称就可以访问，无须通过对象。

public class staticTest {
    public static void main(String[] args) {
        Person per1 = new Person();
        Person per2 = new Person();
        per1.name = "小韩";
        per1.age = 18;
        per1.print();
        per2.print();
        Person.country="日本";
        per1.print();
        per2.print();
        System.out.println(Person.country);
    }
}
class Person {
    //实例变量，成员方法，必须通过该类的对象来访问
    String name;
    int age;
    String sex;
    //静态成员变量，不属于对象，属于类，保存在方法区中
    // 调用时通过 类名称.country来进行访问
    static String country = "中国";
    void print(){
        System.out.println("name:"+name+", age:"+age+", country:"+country);
    }
}

输出结果如下：

注意：
Person per = null;
System.out.println(per.country);//相当于Person.country
并不会报空指针异常：static属性称为类属性，通过类名称直接访问，此时没有对象也能调用（包含该类的null引用）

final 和 static 的区别：

class Person {
final int age = 18;//成员常量，在堆中存储，必须在定义时就赋值
static String country = "中国"//静态变量，在方法区中存储，所有Person类的对象共享
}

若在类中定义了一个常量，通常情况下都会把static 和 final 共同使用，称为类的常量

（因为age属于成员常量，Person类的所有对象都有age这个属性，且值都是18——>天然的共享概念，将它定义为static final，所有Person类的对象共享这个属性，全局唯一。（既节省空间，有对应共享语义））

全局常量的命名规则：所有单词全部大写，多个单词使用下划线分隔

static final String STUDENT_SCHOOL ="清华大学";

小问题：能否在方法中定义一个static变量？

答：不能。在方法中定义的变量是局部变量，在栈中存储，而static变量是在方法区中存储，若要在方法中定义一个static变量就会产生矛盾，因为一个变量不可能既在栈中存储，又在方法区中存储。

3.2 static修饰方法（类方法、工具方法）

static修饰的方法通过类名称直接访问方法，没有对象也可以访问。

小问题：为什么static 方法是一个静态方法？
答：因为主方法是程序的入口，在进入主方法前没有对象， 如果主方法是一个成员方法，需要通过对象调用，就会产生矛盾。要使程序开始执行，只有通过类名称直接调用静态方法，无须产生对象。

问题3：静态方法能否访问成员变量和成员方法？
答：不能。 静态方法可以通过类名称直接访问，此类中没有对象也可以访问；成员方法和成员变量必须要通过类中的对象来访问。没有对象的方法去调用必须通过对象访问的变量和方法，二者之间矛盾。

四.面向对象的特征

面向对象一共有三大特性：封装、继承和多态

封装：保护性和易用性

封装有很多表现形式，private实现属性和方法的封装只是其中一种。
权限修饰符：在Java中，权限修饰符指的是所修饰的属性、方法或者类可见的范围有多大。
一共有四大访问修饰修饰符，可见的范围由小到大依次为 :
private（私有的）：被private 修饰的属性和方法，只在当前类可见，出了类的{ }，对外就完全隐藏了，外部不知道有其存在。
default(不需要写这个关键字，什么权限也没有（包访问权限）)
protected（继承访问权限）
public（公共的、公开的）：被public 修饰的，在当前程序（项目）中都是可见并且可以使用的。

小问题：private 关键字能否修饰一个类（外部类）？
答：不能。定义类是为了产生对象，让外部使用的。若用 private关键字封装此类，则外部根本不知道此类的存在，更不用提使用对象了，矛盾。

五.构造方法

1、构造方法：构造方法是类中非常特殊的一类方法，使用关键字new 实例化对象时实际上调用的就是该类的构造方法。

2.构造方法的作用就是产生对象

3.使用new关键字产生一个对象时，大致分为以下两步：

（1）为对象在堆中分配空间（空间大小由该类中成员变量的属性决定）

（2）调用对象的构造方法为对象成员变量赋值（当构造方法调用结束后，该对象初始化完成）

4.构造方法的语法规则

（1）方法名称与类名称完全相同

（2）构造方法没有返回值声明（不是void）

（3）一个类中至少存在一个构造方法，若没有显示定义，编译器会生成一个默认的无参构造。

public class Test {
    public static void main(String[] args) {
        //当创建一个对象时，默认调用该类的构造方法
        Person person = new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
    //构造方法名称与类名称完全相同
    //没有返回值声明
    public Person(){
        System.out.println("Person的构造方法");
    }
}

若没有定义构造方法，编译器会生成一个默认的无参构造

public class Test {
    public static void main(String[] args) {
        //当构造对象时，默认调用该类的构造方法
        Person person = new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
}

当类中自定义了构造方法，默认的无参构造就不再生成。

public class Test {
    public static void main(String[] args) {
        //当构造对象时，默认调用该类的构造方法
        Person person = new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
    public Person(String n){
        name = n ;
        System.out.println("Person类的有参构造");
    }
}