面向对象查缺补漏Java类及类成员

Java面向对象(查缺补漏——壹)

学习面向对象的三条主线

一、java类及类成员：属性、方法、构造器;代码块、内部类

• 现实世界中，大到鲸鱼小到蚂蚁，都是由最基本的细胞构成的，同理，java代码世界是由诸多的，不同功能的类构成的

• 现实世界中的细胞又是由什么构成的呢？细胞质、细胞核…那么，Java中用class来描述事物也是如此
  属性 = 成员变量 = filed = 域、字段
  方法 = 成员方法 = 函数 = method

二、面向对象的三大特征：封装性，继承性，多态性
三、其它关键字：this、super、static、final、abstract、interface、package、import等…
面向过程(POP):强调的是功能行为，以函数为最小单位，考虑怎么做
面向对象(OOP):强调了具备功能的对象，以类/对象为最小单位，考虑谁来做

面向对象的思想概述

类(Class)和对象(Object)是面向对象的核心概念

• 类 是对一类事物的描述，是抽象的，概念上的定义
• 对象 是实际存在的该类事物的每个个体,因而也称为实例(instance)
• 举例：人
  可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
• 面向对象程序设计的重点就是类的设计
• 设计类 就是 设计类的成员

类和对象的使用或者称为(面向对象思想落地的实现)

1.创建类，设计类的成员

//1.创建类，设计类的成员
class Person {
    //属性
     String name;
     int age = 1;
     boolean isMale;

    //方法
    public  void eat(){
        System.out.println("人可以吃饭");
    }

    public void sleep(){
        System.out.println("人可以睡觉");
    }

    public void talk(String language){
        System.out.println("人可以说话，使用的是" + language);
    }
}

2.创建类的对象

//测试类
public class PersonTest {
    public static void main(String[] args) {
        //2创建person类的对象
        Person person = new Person();

        //3.调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        person.name = "tom";
        person.isMale = true;
        System.out.println(person.name);

        //调用方法：“对象.方法”
        person.eat();
        person.sleep();
        person.talk("中文");

        /******************************/
        Person person2 = new Person();

    }
}

3.通过“对象.属性”或“对象.方法”调用对象的结构(代码见测试类)

类的多个对象的关系

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性(注意：属性是非static的)
意味着:如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值;

/******************************/
Person person2 = new Person();
//打印Person2的name 问 此时是不是tom?
System.out.println(person2.name); //打印结果为null(原因：每new一次 都会在堆空间生成一个新的数据结构 此时堆空间有两个对象实体)
/******************************/
//将person变量保存的地址值赋给person3，导致person和person3指向了堆空间中的同一个对象实体
Person person3 = person;
//问此时person3.name输出的值会是什么？
System.out.println(person3.name);//结果输出为tom, 其实这里不是创建person3对象，只是将person这个对象赋值给person3。(变量名不同而引用堆空间地址(对象)相同)

代码测试接上面测试类即可！

对象的内存解析(详细可看JVM相关资料)

属性与局部变量的对比

/*

• 类中属性的使用

• 属性(成员变量) VS 局部变量

• 1.相同点：

• 1.1定义变量的格式是一样的：数据类型 变量名 = 变量值;

• 1.2只要是变量都是先声明后使用

• 1.3变量都有其对应的作用域

• 2.不同点：

• 2.1在类中声明的位置不同

• 属性：直接定义在类的一对大括号内{}

• 局部变量：将声明在方法内、方法形参，代码块内、构造器形参、构造器内部的变量称为局部变量

• 2.2关于权限修饰符的不同

• 属性：可以在声明属性时，指明其权限，使用权限修饰符

•    常用的权限修饰符：public private 缺省 protected --->封装性详说
  

• 局部变量：不可以使用权限修饰符的

• 2.3默认初始化值的问题

• 属性：类的属性，根据其类型，都有默认初始化值

•    整型(byte、short、int、long)：0
  

•    浮点型(float、double)：0.0
  

•    字符型(char)：0(或'/u000')
  

•    布尔型(boolean)：false
  

•    引用类型(类、数组、接口)：null
  

• 局部变量：没有默认初始化值

•       意味着：我们在调用局部变量之前，一定要显示赋值
  

•       特别地：形参，在调用时，我们赋值即可
  

• 2.4在内存中加载的位置不同

• 属性：加载到堆空间中(非static的，static声明的属性则是放在方法区)

• 局部变量：加载到栈空间

• */

public class UserTest {
   public static void main(String[] args) {
       User user = new User();
       System.out.println(user.name);
       System.out.println(user.age);
       System.out.println(user.isMale);
   }
}

class User{
   //属性(成员变量)
   String name;
   int age;
   boolean isMale;

   public void talk(String language){//language称为形参
       System.out.println("我们使用" + language + "进行交流");
   }

   public void eat(){
       String food = "烙饼"; //局部变量food
       System.out.println("北方人喜欢吃" + food);
   }
}

方法举例与声明的格式

* 类中方法的声明和使用
*
* 方法：描述类应该具有的功能
* 比如：Math类：sqrt()\random()\...
*      Scanner类：nextXxx()..
*      Arrays类：sort() \ binarySearch() \ toString()...
* 1.举例:
*   public void eat(){}
*   public void sleep(int hour){}
*   public String getName(){}
*   public String getNation(String nation){}
* 2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){ //形参可以有多个
*                        方法体
*   }
*   注意：这里不涉及static、final、abstract修饰的方法
*
* 3.说明：
*       3.1 关于权限修饰符：
*           java规定的4种权限修饰符：private、public、缺省、protected --->权限问题封装性细说
*       3.2 返回值类型：有返回值  VS 没有返回值
*           3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值类型。同时，方法中，需要使用return关键字
*                    来返回指定类型的变量或常量。
*                 如果方法没有返回值，则使用，void来表示。通常，没有返回值的方法中，就不需要使用return
*                    但是，如果使用的话，只能“return;” 表示结束此方法的意思
*           3.2.2 我们定义方法时，到底该不该有返回值？
*                   ① 先看需求，如果需要有返回值，那么定义方法必须带返回值
*                   ② 全凭经验
*           3.3 方法名：属于标识符，遵循标识符的规则和规范，同时要“见名知意”
*           3.4 形参列表：方法可以声明，0个、1个，或者多个形参
*                格式：数据类型1 形参1，数据类型2 形参2，...
*           3.5 方法体
*                方法功能的具体实现过程
*

public class CustomerTest {
    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.eat();
    }
}


class Customer{

    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("客户要吃饭了...");
        return;
        //return后不可以使用表达式
        /*System.out.println("吃完了");*/
    }
    public void sleep(int hour){
        System.out.println("休息了" + hour + "小时");
    }
    public String getName(){
        return name;
    }
    public String getNation(String nation){
        String info = "我的国籍是" + nation;
        return info;
    }

}

可变个数形参的方法

/*
* 可变个数形参的方法
*
* 1.jdk5.0新增的内容
* 2.具体使用：
*   2.1 可变个数形参的格式：数据类型 ... 变量名
*   2.2 当调用可变个数形参方法时，传入的参数个数，可以是0个，1个，多个
*   2.3 可变个数形参的方法，与本类中方法名相同，形参不同的方法之间构成重载
*   2.4 可变个数形参的方法与本类当中，方法名相同，形参类型也相同的数组之间不构成重载，换句话说，他们二者不能共存。
*   2.5 可变个数形参，在方法的形参中，必须声明在末尾
*   2.6 可变个数形参，在方法的形参中，最多只能有一个存在

*
* */

public class MethodArgsTest {

    public static void main(String[] args) {
        MethodArgsTest methodArgsTest = new MethodArgsTest();
        methodArgsTest.show(12);
        methodArgsTest.show("hello");
        methodArgsTest.show("hello","world");
        methodArgsTest.show();
    }

    public void show(int i){

    }

    //一个参数优先匹配
    public void show(String s){
        System.out.println("show(String)");
    }

    public void show(String ... strs){
        System.out.println("show(String ... strs)");
    }

    /*public void show(String[] args){}*/

    //方法重载，可变个数形参必须写在形参列表的最后
    public void show(int i,String ... strs){}
}

构造器的基本理解

构造器(或构造方法、constructor)的使用
constructor：建设，建造
①、构造器的作用：
1.创建对象
2.初始化对象的属性
②、说明：
1.如果没有显示的定义类的构造器的话，系统就默认提供一个空参构造器
2.定义构造器的格式：权限修饰符 + 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显示的，定义了类的构造器之后，系统就不再提供默认的空参构造器了
5.一个类中，至少会有一个构造器

public class PersonTest {
    public static void main(String[] args) {
        //创建person类的对象 ：new + 构造器
        Person person = new Person();

        Person tom = new Person("tom");
        System.out.println("有参构造器创建的对象的名称"+tom.name);
	}
    //1.创建类，设计类的成员
class Person {

    //属性
     String name;
     int age = 1;
     boolean isMale;

     //构造器
    public Person(){
        System.out.println("Person().....");
    }

    public Person(String name){
        this.name = name;
        System.out.println("Person().....");
    }
	}
}

有参构造器对属性进行赋值，Tom赋给形参n，形参n赋给类中属性name，这个name是当前正在创建的这个p1对象的

JavaBean的使用

所谓JavaBean，是指符合如下标准的Java类：

• 类是公共的
• 有一个无参公共的构造器
• 有属性，且有对应的get、set方法