1 面向对象的概念

面向对象就是一种常见的思想，符合人们的思考习惯。
面向对象的出现，将复杂的问题简单化。
面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

面向对象的开发、设计和特征
- 开发：就是不断的创建对象，使用对象和指挥对象做事情。
- 设计：其实就是管理和维护对象之间的关系。
- 面向对象的特征：封装、继承和多态

2 类与对象的关系

我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
我们是如何表示一个现实世界的事物呢？
- 属性：就是该事物的描述信息。
- 行为：就是该事物能够做什么。　　
Java语言最基本的单位是类，所以，我们就应该把事物用一个类来表示。

类：是一组相关属性和行为的集合。
对象：是该类事物的具体体现。
举例：类--学生，对象--班长。

类的定义
- 现实世界的事物
  - 属性人的身高，体重等。
  - 行为人学习，吃饭等。

Java中用class来描述事物也是如此。
- 成员变量，就是事物的属性。
- 成员方法，就是事物的行为。　　
定义类其实就是定义类的成员（成员变量和成员方法）。

示例：汽车

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +""+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car = new Car();
        car.num = 4;
        car.color = "红色";

        car.run();
    }
}

成员变量和局部变量的区别？
- ①在类中的位置不同
  - 成员变量定义在类中方法外。
  - 局部变量定义在方法内或者方法声明上。　　　　
- ②在内存中的位置不同
  - 成员变量，在堆内存。
  - 局部变量，在栈内存。　　　　
- ③生命周期不同
  - 成员变量，随着对象的存在而存在，随着对象的消失而消失。
  - 局部变量，随着方法的调用而存在，随着方法的调用完毕而消失。　　　　
- ④初始化值不同
  - 成员变量，有默认的初始化值。
  - 局部变量，没有默认的初始化值，必须先定义，赋值，再使用。

解析对象的内存体现
- 示例：

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.num = 4;
        car1.color = "红色";

        Car car2 = new Car();
        car2.num = 4;
        car2.color = "黑色";

        car1.run();
        car2.run();
    }
}

- 示例：

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.num = 4;
        car1.color = "红色";

        Car car2 = car1;

        car1.run();
        car2.run();
    }
}

匿名对象
- 定义：就是没有名字的对象，是对象的一种简化表现形式。
- 使用场景：
  - 对象调用方法仅仅一次的时候。
  - 作为实际参数传递。　　　　
- 示例1：

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();


        new Car().run();
    }
}

- 示例2：

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {

        show(new Car());


    }
    public static void show(Car c){
        c.num = 4;
        c.color = "黑色";
        c.run();
    }
}

3 封装

封装：是指隐藏对象的属性和实现细节，仅仅对外提供公共访问方式。
封装的好处：
- 将变化隔离。
- 便于使用。
- 提高重用性。
- 提高安全性。　　
封装的原则：
- 将不需要对外提供的内容都隐藏起来。
- 把属性都隐藏，提供公共方法对其访问。

示例：

package java006;

/**
 * 2017/9/6
 * 说明：人类
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0 && age <=200){
            this.age = age;
        }

    }

    public void speak(){
        System.out.print("我的年龄是："+age);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(-1);
        p.speak();
    }

}

4 构造函数

特点：
- 函数名和类名相同。
- 不用定义返回值类型，连void都没有。
- 没有具体的返回值。　　
作用：
- 给对象进行初始化。　
注意：
- 如果你不提供构造方法，系统会给出默认的构造方法。
- 如果你提供了构造方法，系统就不会再提供。
- 构造方法时可以重载的。

示例：

package java006;

/**
 * 2017/9/6
 * 说明：人类
 */
public class Person {
    private int age;
    private String name;

    public Person(){

    }

    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0 && age <=200){
            this.age = age;
        }

    }

    public void speak(){
        System.out.print("我的姓名是："+this.name+"我的年龄是："+age);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person("张三",26);
        p.speak();
    }

}

构造函数和一般函数有什么区别？
- ①
  - 构造函数：创建对象的时候，就会调用与之对应的构造函数，对对象进行初始化。
  - 一般函数：对象创建完毕，需要函数功能的时候才会调用。　　　　
- ②
  - 构造函数：对象创建的时候，会调用并且只调用一次。
  - 一般函数：对象创建后，可以被调用多次。

5 this关键字

this代表其所在函数所属对象的引用。话句话说，this代表的是本类对象的引用。

什么时候使用this关键字呢？
- 当在函数内需要用到调用该函数的对象的时候，就用this。
- 注意的是，方法被那个对象调用，this就代表那个对象。

示例：

package java006;

public class Person {
    private String name;
    private int age;
    
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public void speak() {
        System.out.println(name+" "+age);
    }

    
    

}

package java006;

public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person("哈哈",23);
        p.speak();
        
        Person p2 = new Person("呵呵",29);
        p2.speak();
        
    }
}

6 static关键字

static关键字，用于修饰成员（成员变量和成员函数）。
被修饰的成员具备以下的特点：
- ①随着类的加载而加载。
- ②优先于对象存在。
- ③被所有对象所共享。
- ④可以直接被类名调用。　　
注意事项：
- ①静态方法只能访问静态成员。
- ②静态方法不可以写this，super关键字。
- ③主函数是静态的。

主函数
- 特点：
  - ①格式是固定的。
  - ②被JVM所识别。　　　　
- 详细说明：
  - public 权限必须是最大的。
  - static 不需要对象，让虚拟机通过类名.main()调用。
  - void 主函数没有具体的返回值。
  - main 函数名，不是关键字，只是一个JVM所识别的固定的名称而已。
  - String[] args 主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

package java006;

/**
 * 2017/9/9
 * 说明：String[] args
 */
public class ArgsDemo {
    public static void main(String[] args) {
       System.out.println(args);//[Ljava.lang.String;@1b6d3586  说明args有对象

       System.out.println(args.length);//0 说明jvm传递的是new String[0];
    }
}

静态的应用
- 静态变量：当分析这个对象所具备的成员变量都是相同的时候，这时这个成员变量就可以使用static修饰。只要数据在对象中是不同的，就是对象的特有数据，必须存储在对象中，是非静态的；如果是相同的数据，对象不需要再做修改，只需要使用即可，那么就不需要存储在对象中，定义成static即可。
- 静态函数：函数是否用static修饰，就是看该函数工鞥呢是否访问了对象的特有数据，如果有，那就不要使用static修饰函数；如果没有，可以使用static修饰函数。换句话说，静态函数只能访问静态变量，而普通函数可以访问静态变量或普通变量。

静态代码块

package java006;

/**
 * 2017/9/9
 * 说明：静态代码块，随着类的加载而加载，而且只执行一次。
 * 作用：静态代码块给类进行初始化。
 */
class StaticCode{

    static {
      System.out.println("静态代码块");
    }
    public StaticCode(){
        System.out.println("构造方法");
    }

    public void show(){
        System.out.println("show方法");
    }

}
public class StaticCodeDemo {
    public static void main(String[] args) {
        new StaticCode().show();
        new StaticCode().show();
    }

}

构造代码块

package java006;

/**
 * 2017/9/9
 * 说明：静态代码块，随着类的加载而加载，而且只执行一次。
 * 作用：静态代码块给类进行初始化。
 */
class StaticCode{


    {
        System.out.println("构造代码块");
    }
    static {
      System.out.println("静态代码块");
    }
    public StaticCode(){
        System.out.println("构造方法");
    }

    public static void show(){
        System.out.println("show方法");
    }

}
public class StaticCodeDemo {
    public static void main(String[] args) {
        StaticCode.show();
    }

}

package java006;

/**
 * 2017/9/9
 * 说明：静态代码块，随着类的加载而加载，而且只执行一次。
 * 作用：静态代码块给类进行初始化。
 */
class StaticCode{


    {
        System.out.println("构造代码块");
    }
    static {
      System.out.println("静态代码块");
    }
    public StaticCode(){
        System.out.println("构造方法");
    }

    public static void show(){
        System.out.println("show方法");
    }

}
public class StaticCodeDemo {
    public static void main(String[] args) {
        new StaticCode();
        new StaticCode();
    }

}

- 从中，我们可以得出以下结论：
  - 构造代码块，可以给所有对象初始化。
  - 构造函数，是给对应的对象进行针对性的初始化。

使用static封装数组工具

package java006;


/**
 * 2017/9/9
 * 说明：数组工具
 */
public class ArrayTool {

    private ArrayTool(){}


    /**
     * 输出数组中的元素
     * @param arr
     */
    public static void printArray(int[] arr){
        if(arr == null ||arr.length ==0){
            throw new RuntimeException("数组为空");
        }
        System.out.print("[");
        for(int x = 0;x<arr.length;x++){
            if(x == arr.length - 1){
                System.out.print(arr[x]+"]");
            }else{
                System.out.print(arr[x]+"、");
            }

        }
    }


    /**
     * 获取数组中的最大值
     * @param arr 数组
     * @return 最大值
     */
    public static int getMax(int[] arr){
        if(arr == null ||arr.length ==0){
            throw new RuntimeException("数组为空");
        }

        int max = arr[0];
        for(int x =1;x<arr.length;x++){
            if(max < arr[x]){
                max = arr[x];
            }
        }
        return  max;
    }

    /**
     * 选择排序
     * @param arr
     */
    public static void sortByChange(int[] arr){
        if(arr == null ||arr.length ==0){
            throw new RuntimeException("数组为空");
        }

        for(int x =0;x < arr.length-1;x++){
            for(int y = x+1;y<arr.length;y++){
                if(arr[x] > arr[y]){
                   swap(arr,x,y);
                }
            }
        }
    }

    /**
     * 冒泡排序
     * @param arr
     */
    public static void sortByBubble(int[] arr){
        if(arr == null ||arr.length ==0){
            throw new RuntimeException("数组为空");
        }
        for(int x =0;x<arr.length-1;x++){
            for(int y = 0;y<arr.length-1-x;y++){
                if(arr[y] > arr[y+1]){
                    swap(arr,y,y+1);
                }
            }
        }


    }


    /**
     * 数组两个元素交换位置
     * @param arr
     * @param x
     * @param y
     */
    private static void swap(int[] arr, int x, int y) {
        if(arr == null ||arr.length ==0){
            throw new RuntimeException("数组为空");
        }
        if(x <0 || y<0){
            throw new RuntimeException("索引不能为负数");
        }
        int temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;




    }


}

package java006;

/**
 * 2017/9/9
 * 说明：
 */
public class ArrayToolTest {
    public static void main(String[] args) {
        int[] arr = {4,8,2,9,7,6};
        //排序前
        ArrayTool.printArray(arr);

        //获取最大值
        System.out.print("最大值："+ArrayTool.getMax(arr));


        //排序后
        ArrayTool.sortByChange(arr);
        ArrayTool.printArray(arr);

    }
}

7 单例设计模式

设计模式：对问题行之有效的解决方案。
单例设计模式：就是保证一个类在内存中的对象具有唯一性。

饿汉式单例设计模式：

package java006;

/**
 * 2017/9/9
 * 说明：单例设计模式
 */
public class Singleton {
    private static Singleton singleton = new Singleton();
    private Singleton(){}
    
    public static Singleton getInstance(){
        return singleton;
    }
}

懒汉式单例设计模式：

package java006;

/**
 * 2017/9/9
 * 说明：单例设计模式
 */
public class Singleton {
    private static Singleton singleton = null;
    private Singleton(){}

    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;

    }
}

JAVA学习网

分类

面向对象

1 面向对象的概念

2 类与对象的关系

3 封装

4 构造函数

5 this关键字

6 static关键字

7 单例设计模式