JavaSE-面向对象编程（上）

一、面向对象编程(OOP Object Oriented Programming)
1、面向对象与面向过程?
面向过程：强调的是功能行为
面向对象：将功能行为封装进对象，强调的是具备了功能行为的对象
【例】把大象装冰箱一共分几步？
①打开冰箱 ②把大象装进去(存储大象) ③关闭冰箱
如何运用面向对象思想思考上述问题？
人{
拉(冰箱){
冰箱.打开()
}
指挥(动物){
动物.进入()
}
推(冰箱){
冰箱.关闭()
}
}
冰箱{
打开(){}
存储(){}
关闭(){}
}
大象{
进入(){}
}
长颈鹿{
进入(){}
}
2、面向对象更加注重前期对类的设计
设计类就是设计类的成员：属性 & 方法
3、面向对象编程思想融入到 Java 代码中
将现实生活中一类事物的共性内容进行提取，抽象成相应的 Java 类，使用 Java 中的类对其进行描述
现实生活中的一类事物：小猫 小狗
共性内容：名称 年龄 性别 吃饭的功能 睡觉的功能

//抽象的
class Animal{
    
    //属性-变量
    String name = "";
    int age;
    char gender;
    
    //行为-方法
    public void eat(){
        System.out.println("吃饭的功能");
    }
    
    public void sleep(){
        System.out.println("睡觉的功能");
    }
    
}

类本身是抽象的，因为类描述的是现实生活中的“一类”事物
若需要具体到某“一个”事物，通过 new 关键字创建对象

//创建 Animal 的对象
Animal ani = new Animal();

//为属性赋值
ani.name = "金毛";
ani.age = 2;
ani.gender = '公';

//获取属性值
String n = ani.name;
System.out.println(n + "," + ani.age + "," + ani.gender);

//调用该对象的方法
ani.eat();
ani.sleep();

4、类和对象
类：抽象的，描述的是现实生活中的一类事物。 类似于：汽车设计图
对象：一个实实在在的个体。 类似于：一辆辆的汽车

二、对象的属性和方法

属性的特点
属性也叫成员变量，也叫实例变量
1、成员变量与局部变量的区别
①作用域不同
②内存中的位置不同
③成员变量有默认值，而局部变量没有默认值
2、属性的默认值
基本数据类型：
byte short int —> 0
long —> 0L
float —> 0.0F
double —> 0.0D
char —> ‘\u0000’
boolean —> false
引用数据类型： ----> null
|–类(class)
|–接口(interface)
|–数组([])
3、为属性赋初始值的方式
①默认值(缺省值)
②直接显示赋值

三、参数的值传递之引用数据类型

基本数据类型：（详见上节文章）
引用数据类型：当将引用数据类型作为参数，传递给方法，方法运行结束后，原对象属性值会发生改变

class MethodTest{
    
    public static void main(String[] args){
        //变量的格式：数据类型 变量名 = 值;
        /*int a = 10;
        boolean b = true;
        char ch = 'A';
        
        //
        Person p = new Person();*/
        
        //add(new Number()); 匿名对象
        
        Number num = new Number();
        num.a = 10;
        num.b = 20;
        
        add(num);//是值传递还是引用传递？
        
        System.out.println("num.a=" + num.a + " num.b=" + num.b);//num.a=11 num.b=22
    }
    
    public static void add(Number num){//相当于：Number num = new Number();
        
        num.a += 1;
        num.b += 2;
        
    }
    
}

class Number{
    
    int a;
    int b;
    
}

四、面向对象的特性之一：封装性

1、封装的理解
把该隐藏的隐藏起来，该暴露的暴露出来
2、访问控制修饰符
public : 公共的，可用于修饰 属性、方法、类。 在任何地方都可以访问
private : 私有的，可用于修饰 属性、方法。 只能在本类中访问
3、封装的步骤
①属性私有化(private)
②提供公共的(public) get/set 方法

class EncapsulationTest{
    
    public static void main(String[] args){
        Animal a1 = new Animal();
        //a1.name = "大象";
        //a1.legs = -4;
        
        a1.setName("大象");
        a1.setLegs(4);
        
        System.out.println(a1.getName() + "," + a1.getLegs());
    }
    
}

class Animal{
    
    private String name;
    private int legs; //描述腿的个数
    
    public void setName(String n){
        name = n;
    }
    
    public String getName(){
    	return name;
    }
    
    //设置属性值
    public void setLegs(int l){
        if(l > 0 && l % 2 == 0){
            legs = l;
        }
    }
    
    //获取属性值
    public int getLegs(){
        return legs;
    }
}

五、this 关键字

使用在本类中，代表当前对象，可用于调用 属性、方法、构造器
this.属性
this.方法
this(……) ：调用本类构造器
注意：
①必须写在当前构造器中可执行代码的首行
②若使用 this 调用本类其他构造器，至少保证一个构造器中不使用 this(), 避免递归构造器调用

class Animal{
    
    private String name;
    private int legs; //描述腿的个数
    
    public void setName(String name){
        this.name = name;//用于区分局部变量和成员变量
    }
    
    public String getName(){
    	return name;
    }
    
    //设置属性值
    public void setLegs(int legs){
        if(legs > 0 && legs % 2 == 0){
            this.legs = legs;
        }
    }
    
    //获取属性值
    public int getLegs(){
        return legs;
    }
    
    public String say(){
        return getName() + "," + this.getLegs();
    }
}

六、构造器的声明和使用

构造器也叫构造方法，是类的成员之一
属性
方法
构造器
1、构造器的格式
访问控制修饰符 类名(参数列表){
//功能语句
}
2、构造器的作用
①用于创建对象
②用于为对象进行初始化
3、构造器的注意
①构造器的名称必须与类名一致！
②若一个类中没有显示的提供任何构造器时，系统会提供一个默认无参的构造器
public Person(){}
③若一个类中显示的提供了任何构造器，系统默认无参构造器将不再提供
④构造器只能调用一次，并且是在创建对象时
⑤构造器可以构成重载
4、构造器的重载
在同一个类中
①构造器的名称相同
②参数列表必须不同(参数的个数、参数的类型)
5、为属性赋初始值的方式
①默认值(缺省值)
②直接显示赋值
③构造器赋值
顺序：①②③

class ConstructorTest{

    public static void main(String[] args){
        Person p = new Person();
        
        Person p1 = new Person("张三");
    }
    
}

class Person{
    private String name;
    private int age;
    private char gender;
    private double height;
    
    //声明一个构造器
    public Person(){
        System.out.println("Person's Constructor……");
    }
    
    public Person(String name){
        //this(name, 18); 注意避免递归构造器调用
        this.name = name;
    }
    
    public Person(String name, int age){
        this(name);
        this.age = age;
    }
    
    public Person(String name, int age, char gender){
        this(name, age); //必须写在当前构造器中可执行代码的首行
        this.gender = gender;
    }
    
    public Person(String name, int age, char gender, double height){
        this(name, age, gender);
        this.height = height;
    }
    
    public Person(String name){
        this.name = name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
}

七、包的管理

1、包的作用
①区分重命名
②控制访问权限
③可用于划分项目的结构层次，通常将功能相近的类划分到同一个包中
2、package
确定当前类的位置
①使用在当前 .java 源文件中可执行代码的首行
②包的命名规范：所有字母都小写。通常使用所在公司域名的倒置
www.itdianbo.com ----> com.itdianbo.项目名.模块名;
③每个 “.” 代表一层目录
3、import
确定需要引入类的位置
①使用在 package 和 class 之间
②import 语句可以有多条，并排列出即可
③import com.itdianbo.test.* ; 代表导入 test 包中所有的类和接口。不包括包
④若在一个类中，使用了两个相同类名不同包名的两个类时
如：java.util.Date; java.sql.Date;
选择一个使用导包的方式： import java.util.Date;
选择另外一个使用全限定类名的方式： java.sql.Date date = new java.sql.Date();
⑤静态导包：import static
例如：import static com.itdianbo.test.StaticClass.*;