ClassAndObject -类与对象 - java（万字篇）

Posted Dark And Grey

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了ClassAndObject -类与对象 - java（万字篇）相关的知识，希望对你有一定的参考价值。

文章目录

类与对象的初步认知

 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
    JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
    面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
    面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来

 

面向对象概念

    1.面向对象是思考问题的一种思考方式，是一种思想。
    2.类就是一类对象的统称。对象就是这一类具体化的一个实例。
    3.面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

 

面向对象设计

    面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据（私有）的方法！
    （被动的一方是数据的拥有者，主动的一方是执行者）
    开发时：找对象，建对象，用对象，并维护对象之间的关系。

简而言之

     面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为

图 1

图 2

通过 图1 和 图2 ,我们更加清楚 面向对象 与 面向过程的区别。

 

那么我们问题是︰对象从何而来，从类来，你可以想象成一个类型，假设我们都是人，额，就这样吧。那么我们要定义一个类,这个类我们要定义出来,该怎么定义呢?

 

类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例

创建类 ( 基本语法 )

class <class_name>{
        field;//成员属性
        method;//成员方法
        }

 实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体（类体）。
类中的元素称为：成员属性（成员变量）。类中的函数称为：成员方法。

代码如下

  注意类的定义是写在我们文件类的外面（初识Java中，我们说了类名要和文件相同，所以我写成文件类，方便你们区别）
class Person{
// 现在我们定义了 一个类 Person （注意类名要大驼峰结构，这个初识Java的时候就讲过了）
    // 类里面包含字段（又称 属性 和 成员变量） 和 方法
    // 字段又称属性，属性什么意思，比如人的属性
    public String name;// 每个人都有自己的名字
    public  int   age; // 年龄
//     这两个成员变量虽然可以赋值，但不推荐，跟前面 数组文章中的不规则二维数组是一样的
    // 可以 根据后期的需要， 进行赋值的，而且你总不能每个人的名字和年龄都一样把。
    // 注意  创建在 在类的内部，方法的外部的变量，被称为 成员变量（属性/字段）
    // 定义写到方法的内部 是 局部变量

 另外 成员变量 又可分为 普通成员变量（该程序的成员变量就是普通的） 和 静态成员变量（static）


    // 而方法（又称 成员方法） 可以解析为 人的行为
    // 比如说吃
    public void eat(){
        System.out.println(name + "正在吃饭。");
    }
    public void sleep(){
        System.out.println(name + "睡着了。");
    }
}

public class ClassAndObject {
    public static void main(String[] args) {
         // 我们经过图1，得出的结论是 有了类才有对象
        // 现在我们有了类，那么怎么产生对象的呢？
        // 通过  new 去实例化一个对象，也就是说去产生一个对象
        Person person = new Person();
        // 注意此时的变量是由类定义的，由类定义的变量，都是引用变量,意味着初值可以赋 null
        //  Person person = null;

        // 而且 前面也说，同一个类，我们可以产生很多对象
        // 意味着 我们生成 很多人 person
        Person person2 = new Person();
        Person person3 = new Person();
        Person person4 = new Person();
        Person person5 = new Person();
        //    .
        //    .
        //    .
    }
}

 

访问 类的成员变量（通过引用来访问）

基本语法

 引用（由类定义的定义的类名）.普通成员变量名

代码实例1

class Person{
    public String name;// 每个人都有自己的名字
    public  int   age; // 年龄
    public void eat(){
        System.out.println(name + "正在吃饭。");
    }
    public void sleep(){
        System.out.println(name + "睡着了。");
    }
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        // 普通成员变量的访问需要 通过对象 的引用（person）来访问的
        System.out.println(person.name);// name 是引用类型，存的是首字符地址
        System.out.println(person.age);//  int 整形
    }// 图 3
}// 图4 ， 图中的默认值，是针对于 成员变量，不包括局部变量，而且局部变量不初始化是无法使用的

图 3

图4（成员变量和引用的默认值）

 

代码实例2

class Person{
    public String name;// 每个人都有自己的名字
    public  int   age; // 年龄
    public void eat(){
        System.out.println(name + "正在吃饭。");
    }
    public void sleep(){
        System.out.println(name + "睡着了。");
    }
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "author";
        person.age =10;
        System.out.println(person.name);
        System.out.println(person.age);
        Person person2 = new Person();
        System.out.println(person2.name);// name 是引用类型，存的是首字符地址
        System.out.println(person2.age);//  int 整形
    }// 图 5
}// 图解6

图5

图6

 

代码实例3 (调用成员方法)

成员方法也和成员变量一样，可分为 普通成员方法 和 静态成员方法（static）

普通成员方法跟普通成员变量是一样的，通过对象的引用来调用

class Person{
    public String name;// 每个人都有自己的名字
    public  int   age; // 年龄
    public void eat(){
        //  eat 和 sleep 可以称其为 方法片段，方法片段 是存储在方法区中
        // 如果方法里 创建了 int a 或者 其他类型的变量，在该方法被调用时，
        // 方法会在栈上开辟内存（没被调用，就放在方法区里）
        // 那么方法的空间就会分出4byte来存储它
        System.out.println(name + "正在吃饭。");
    }
    public void sleep(){
        System.out.println(name + "睡着了。");
    }
}
public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "author";
        person.age =10;
        person.eat();
        person.sleep();
    }// 图 7
}

图 7

 

类的成员

    类的成员可以包含以下：字段、方法、代码块、内部类和接口等
     本文主要讲字段、方法，代码块。

字段 等价于 （属性/成员变量）

成员变量又可分为两类： 普通成员变量，静态成员变量

代码样本1

class Person{
    // 普通成员变量 都是属于对象的
    public String name;// 引用类型（存的字符串首字符地址），默认值为null
    public int age;// 默认值为 0

    // 静态成员变量
    public static  int count;// 默认值为 0

}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 10;// 访问普通成员
        person.count = 1;
        System.out.println(person.age);
        System.out.println(person.count);
    }
}// 图 8

图8

 

代码样本2（访问普通成员变量）

class Person{
    // 普通成员变量 都是属于对象的
    public String name;// 引用类型（存的字符串首字符地址），默认值为null
    public int age;// 默认值为 0
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        person.age++;
        System.out.println(person.age);
        System.out.println("======================");
        Person person2 = new Person();
        person2.age++;
        System.out.println(person2.age);
    }
}// 图 9,10

图9

图10

 

代码样本3（访问静态成员变量）

class Person{
    // 普通成员变量 都是属于对象的
    public String name;// 引用类型（存的字符串首字符地址），默认值为null
    public int age;// 默认值为 0

    public static int count;
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        person.age++;
        person.count++;
        System.out.println(person.age);
        System.out.println(person.count);
        System.out.println("======================");
        Person person2 = new Person();
        person2.age++;
        person2.count++;
        System.out.println(person2.age);
        System.out.println(person2.count);
    }
}// 图 11,12

图11

图12

 

代码样本4（由图12得出的结论，修改样本3）

class Person{
    // 普通成员变量 都是属于对象的
    public String name;// 引用类型（存的字符串首字符地址），默认值为null
    public int age;// 默认值为 0

    public static int count;
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();// 没意义，静态成员变量属于类，所以实不实例化一个对象。没有影响
        Person.count++;
        System.out.println(Person.count);
        System.out.println("======================");
        //Person person2 = new Person(); 没意义

        Person.count++;
        System.out.println(Person.count);
    }
}// 图 13

图13

 

代码样本5 （调用【静态成员方法/类方法】）

class Person{
  // 静态成员方法/类方法
    public static  void staticFunc(){
        System.out.println("static::func()");
    }
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person.staticFunc();
    }
}// 图 14

图14

 

注意事项 1（能不能在方法中 创建一个 被 static修饰的变量）

class Person{
    // 普通成员办法
    public void eat(){
        static int size = 0;// 该写法是错的
    }


    // 静态成员方法/类方法
    public static  void staticFunc(){
       static int size2 = 0;// 该写法是错了
    }
}// 图 15

图15

总结：

    无论是 普通成员方法还是静态成员方法，都不能在其内部创建一个被static修饰的变量
因为 被static修饰了的变量，该变量就属于类了（类变量/静态变量）。
 而你把一个（类变量/静态成员变量）写在方法里，就意味着属于方法（是一个局部变量，不再是 类变量了），而不属于类
 所以冲突了，不合适，导致编译器报错。

还有一个原因
拿eat来说， eat是普通成员方法，是需要对应的引用来调用的。但是如果可以定义static的变量， 通过 类名Person 就能调用。
 一个需要对象，不需要类；另一个需要类，不要有对象，两者就像在这里卡bug一样存在冲突。所以这种写法是错的

而静态成员方法中，之所以不能创建一个被 static修饰的变量，是因为，你是在内部定义的。在内部定义，就意味着属于方法，而不属于类，所以错的

 总得来说： 只要是被 static 修饰的变量/方法，都是属于类的。

 

注意事项 2（能不能在方法中调用方法）

普通成员方法 调用动态成员方法

class Person{
    public String name = "author";

    public void eat(){
        staticFunc();// 可以这样写，没有警告
        System.out.println(name+"正在吃饭.");
    }

    public static  void staticFunc(){
        System.out.println("static::func()");
    }
}

public  class ClassAndObject {
    OOZIE：JA009：RPC 响应超出最大数据长度


 第四章：jianja2模板用法


 如何在OSX上解压缩omni.ja？


 为啥我的 ja.lproj 不显示日语？


 EI检索期刊JA检索与CA检索有什么区别?


 LDAP 与 MYSQL .. JA-SIG CAS 与 LDAP 与 CAS 与 MySQL