Java基础知识之面向对象（1）

什么是面向对象：

比如我们想做一个盒子，先想一下盒子的样子，然后找具体的工具来做出我们想要的盒子，这个过程就是面向对象。

面向对象的特征

封装、继承、多态
封装：内部资源对外部不可见
继承：扩展现有类的功能
多态：方法可以重载，对象可以有多个形态

类与对象的理解

类：具有相同特征的一类事物（如：两个眼睛，一个鼻子，一个嘴的人，人就是一个类），
Java中定义类的具体方法：

class 类名称{
    成员变量；
    ....
    成员方法；
}

对象：一个类的具体体现，对于上面说的人，任何一个个体都是一个对象，如张三，李四，你，我，都是人这个类的一个具体实例。
Java中对象的定义方法：

//我们先写一个类，名字为Person
class Person{
    int age;
    String name;

    public void tell(){
        System.out.println("我的名字是"+name+",我今年"+age+"岁了!");
    }
}

//有了自己的类后，我们可以这样声明并实例化一个对象
Person per = new Person();//声明并实例化

per.tell();//调用类中的方法
//当然，我们也可以使用java提供的类，来实例化对象。

类图

通过一个类的类图可以很清晰的看到该类的结构是如何的，下面来看一下如何弄一个类图出来。

首先，一个类图分为三层：类名称，成员变量，成员方法，他们从上到下排列。
其次，成员变量由 访问权限 变量名称 : 类型构成。
再者，成员方法由 访问权限 方法名称():返回值 构成。
注：访问权限中，私有的用 - 表示，公共的用+表示。

在对象的声明和实例化过程中的内存分配动作

Person per = new Person();//声明并实例化

在这句代码中，内存的分配动作是这样的：

//为了容易理解，我们改写上面的代码为：
Person per = null;//声明对象
per = new Person();//实例化对象

构造方法

1、什么是构造方法
在例子
new Student();
Student()就是类Student类中的一个无参数构造方法，它和普通的成员方法的区别是：名称和类名称一样、不能有返回值(和返回值void不同)
2、构造方法的主要作用是用于对象成员变量的初始化。
3、我在一个类中并没有写构造方法，调用的是从哪里来的？
若一个类中没有显示的写出构造方法，java会自动加入一个无参数的构造方法。
4、若有显示的写出有参数的构造方法，则无参构造不会自动加入。
5、构造方法一样可以重载。

匿名对象

见名知意，就是没有名字的对象，只能使用一次，在栈内存中并无该对象的引用。

this,super关键字 的区别

static关键字

1、若一个类中存在static修饰的成员变量，则该类的所有实例共享这一个变量。
2、类中的static修饰的成员变量可以由 类名称.变量名直接调用，static变量存在于对象之外。
3、static修饰的方法只能调用static修饰的方法和变量

代码块

1、什么是代码块
由{}构成的代码片段为代码片段，根据其所在位置不同，可以分为：普通代码块、构造代码块、静态代码块、同步代码块
2、普通代码块：
直接出现在一个方法中的代码片段

public static void main(String[] args){
    {
    .....
    //这里是普通代码块
    .....
    }
}

3、构造代码块
直接出现在类中，无论位置如何，优先于构造函数执行，每有对象产生，就会执行构造块

class A{
    {
    ...
    //构造代码块
    ...
    }
    //成员变量
    //构造方法
    //成员方法
}

4、静态块
直接出现在类中，无论位置如何，优先于构造块，构造函数的执行，但只执行一次。

class A{
    static {
        ...
        //静态块
        ...
    }
    {
    ...
    //构造代码块
    ...
    }
}

对象数组

例子：

Person[] pers = new Person[3];
//这里的pers[0]、pers[1]、的值为null，并没有初始化
//可以这样初始化
pers[0] = new Person();
pers[1] = new Person();
pers[2] = new Person();

//还可以这样定义对象数组
Person[] pers = {new Person(),new Person()};

//两种方法都可以完成对象数组的声明和初始化

内部类

一个类的内部还存在一个类，则称为内部类

class out{
    //外部类成员变量
    //外部类成员方法
    class in{
        //内部类成员变量
        //内部类成员方法
        //在该 in 类中可以直接访问外部类的私有成员方法及变量
    }
}

内部类的使用方法：

public class out {
    private int a = 100;

    public void funout(){
        System.out.println("out()");
    }
    public class in{
        public void fun(){
            System.out.println("a = "+a);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        out o = new out();//先实例化外部类
        out.in i = o.new in();//用外部类的对象实例化内部类对象
        i.fun();
    }

}

若内部类用static修饰了，则该内部类变为外部类（普通类），可以通过外部类名.内部类名称直接调用。
方法中的内部类使用：

public class out {
    public void funout(){
        //方法中的内部类
        class in{
            void fun(){
                System.out.println("这是方法中的内部类！");
            }
        }
        new in().fun();
    }
}

public class Main {
    public static void main(String[] args) {
        new out().funout();
    }

}

面向对象的基础知识还是挺多的，下次继续吧！^-^