3面向对象

3.1 一些比较重要的概念

面向对象的三个主要特性：封装性，继承性，多态性

定义类：

public class Person {
//定义成员变量
	private String name;//姓名
	private int age;//年龄
	private char gendar;//性别
//定义成员方法
/**
* study方法
*
*/
	public void study(){
		System.out.println("好好学学习，天天向上");
	}
/**
* sleep();睡觉
*/
	public void sleep(){
		System.out.println("学习一天了，可以睡觉了");
	}
}

由对象调用的方法不加static，不是由对象调用的方法加static

声明并实例化对象

类名称   对象名称   =   new   类名称();

分步完成：

声明对象   类名称   对象名称   =  null;

实例化对象： 对象名称 = new 类名称();

类属于引用数据类型，而引用数据类型与基本数据类型最大的区别在于需要内存的开辟，所以new关键字的作用就是开辟内存空间。 

对于引用数据，我们要知道其实就是一块堆内存空间，能被多个栈内存共同指向

这也是引用传值的原理

3.2 封装性初步分析

使用private关键字 封装类中的属性，这样这两个属性只可以在这个类中被访问

开发中要求类中的属性都给设置成private 然后设置相应的方法给属性赋值

3.3 构造方法

几遍一个用户定义的类没有任何构造方法，也会在程序编译之后自动地为这个类添加一个没有参数，没有方法名称，和类名称相同，没有返回值的构造方法。

package demo01;

class Book{
    private String title;
    private double price;

//这就是Book类的构造方法
    public Book(String t,Double s){
        setTitle(t);
        setPrice(s);
    }

    public void setTitle(String t){
        title = t;
    }
    public void setPrice(double s){
        if(s > 0){
            price = s;
        }
    }
    public String getTitle(){
        return title;
    }
    public double getPrice(){
        return price;
    }
    public void getInfo(){
        System.out.println("TITLE: "+title+" PRICE: "+price);
    }
}
public class TestDemo05 {
    public static void main(String[] args) {
        Book book1 = new Book("了不起的盖兹比",100.56);
        System.out.println(book1.getPrice());
        book1.setPrice(500);
        book1.getInfo();
    }
}

3.4 匿名对象

没有名字，没有栈内存指向的堆内存空间，就是一个匿名对象

class Car{
    private String title;
    private double price;

    public Car(String t,double p){
        title = t;
        price = p;
    }

    public void getInfo(){
        System.out.println("TITLE: "+title+" PRICE: "+price);
    }
}
public class TestDemo06 {
    public static void main(String[] args) {
        new Car("宝马",150000).getInfo(); //匿名对象
    }
}

3.5 简单JAVA类

简单java类是一种在实际开发中使用最多的类的英文形式，再简单Java类中包含类，对象，构造方法，private封装等核心概念的使用

简单java类基本开发要求：

1. 类名称必须要有意义
2. 类中所有属性都要用private封装，封装后的属性必须提供setter，getter
3. 类中可以提供任意多个构造方法，但是必须要留一个无参构造方法
4. 类中不允许出现任何输出语句，所有信息输出必须交给被调用处输出
5. 类中需要有个取得对象完整信息的方法，暂定为getInfo(),且返回String型数据

可以看下书本92页的实例

3.6 数组

数组和类一样，都是引用数据类型

• 声明并开辟数组

数据类型 数组名称  [] = new 数据类型 [长度]

数据类型  []  数组名称  = new 数据类型 [长度]

• 分步完成

声明数组：  数据类型 数组名称 [] = null;

开辟数组：   数组名称 = new 数据类型[长度]；

数组名称.length可以返回数组长度，这是已经定义好的属性

了解一下数组初始化的几种用法

3.6.1 数组与方法参数的决定

数组作为参数的时候，参数就是一个暂时的栈内存，指向了堆内存内的数组，函数结束后就没了

3.62 简单的排序

package demo01;
//简单的排序
public class ArrayDemo {
    public static void main(String[] args) {
        int[] data = new int[] {2,5,44,23,435,5,34,23,2,3,5,66,33};
        sort(data);
        print(data);
    }
    //写个排序的方法
    public static void sort(int tmp[]){
        for (int x = 0; x < tmp.length; x++) {
            for (int i = 0; i < tmp.length - 1; i++) {
                if (tmp[i] > tmp[i+1]){
                    int t = tmp[i];
                    tmp[i] = tmp[i+1];
                    tmp[i+1] = t;
                }
            }
        }
    }
    //写个输出的方法
    public static void print(int tmp[]){
        for (int i = 0; i < tmp.length; i++) {
            System.out.print(tmp[i]+",");
        }
    }
}