面向对象的基础篇_03

版权声明：本文为博主原创文章，未经博主允许不得转载。多多评论，与博主一起学习编程。 https://blog.csdn.net/Roobert_Chao/article/details/78586674

基础篇_03的主要内容

• 1丶对象比较
• 2丶static 关键字的作用
• 3、代码块
• 4丶内部类

一丶对象比较

• 理解：就是判断两个对象的内容是否相等。
• 核心：就是判断两个对象中的属性是否完全相等。

比较的第一种情况

class Person {
    private String name ;
    private int age ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
}
public class CompareDemo01 {
    public static void main(String args[]){
        Person per1 = new Person("张三",30) ;
        Person per2 = new Person("张三",30) ;
        if(per1.getName().equals(per2.getName()) 
            && per1.getAge() == per2.getAge()){
            System.out.println("是同一个人！") ;
        } else {
            System.out.println("不是同一个人！") ;
        }
    }
}

如果按照以上的做法，由主方法进行比较，实际上就相当于增加了一个第三方，由第三方帮你进行比较，肯定不合适，所以最好的做法是在 Person 类中本身就已经具备了一个这样的功能。

class Person {
    private String name ;
    private int age ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public boolean compare(Person person){
        if(this == person){  //  地址相等了
        return true ;
    }
    if(this.name.equals(person.name) && this.age==person.age){
        return true ;
    } else {
        return false ;
    }
}
    public String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
}
public class CompareDemo02 {
    public static void main(String args[]){
    Person per1 = new Person("张三",30) ;
    Person per2 = new Person("张三",30) ;
    if(per1.compare(per2)){
        System.out.println("是同一个人！") ;
    } else {
        System.out.println("不是同一个人！") ;
    }
}

对象比较的操作代码，一定要熟练编写。

二丶static 关键字的作用

• static关键字在类中可以声明属性或方法。
  
  • 声明的属性将称为全局属性。``【全局属性】
  • 声明的方法将成为类方法。``【类方法】

1、声明属性

• 公共属性就可以使用 static 进行操作。
  
  • |- 假使每个对象占用每个对象自己的属性的话，对于每个对象公有的属性而言，肯定会造成内存空间的浪费
  • `|- 公共属性，所有的对象可以同时拥有，但是一般而言这些公共属性虽然可以使用普通的对象调用，可一般不这样操作，而是通过所有对象的最大级 —— 类，完成调用。

举例：

| - 比如我们的学校都在石家庄的话，城市country石家庄是全局属性
| - 我们之间不同的属性就有名字name和学号id

我们的程序如下：

class Person {
    private String name ;
    private int age ;
    String country = "石家庄" ;
    public Person(String name,int age){
            this.name = name ;
            this.age = age ;
    }
    public String getInfo(){
        return "姓名：" + this.name + "，年龄：" + this.age + "，城市：" + country ;
    }
}
public class StaticDemo01{
    public static void main(String args[]){
    Person per1 = new Person("张三",20) ;
    Person per2 = new Person("李四",21) ;
    Person per3 = new Person("王五",22) ;
    System.out.println(per1.getInfo()) ;
    System.out.println(per2.getInfo()) ;
    System.out.println(per3.getInfo()) ;
    }
}

| - 这里没有使用static定义全局变量。
| - 如果需要改变我们的地址为北京，上千人的数据很难一下更改。
| - 按照内存的分配来讲，每一个对象都单独占着各自的 country属性。

我们把程序中的country加上static作为全局变量

class Person {
    private String name ;
    private int age ;
    static String country = "石家庄" ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public String getInfo(){
        return "姓名：" + this.name + "，年龄：" + this.age + "，城市：" + country ;
    }
}
public class StaticDemo02{
    public static void main(String args[]){
        Person per1 = new Person("张三",20) ;
        Person per2 = new Person("李四",21) ;
        Person per3 = new Person("王五",22) ;
        System.out.println(per1.getInfo()) ;
        System.out.println(per2.getInfo()) ;
        System.out.println(per3.getInfo()) ;
        System.out.println("---------------------") ;
        per1.country = "北京" ;
        System.out.println(per1.getInfo()) ;
        System.out.println(per2.getInfo()) ;
        System.out.println(per3.getInfo()) ;
    }
}

|-修改了一个对象中的 country属性之后，所有对象的 country属性都发生了变化
|-由于全局属性拥有可以通过类名称直接访问的特点，所以这种属性又称为类属性。
|-类名称直接访问Person.country = “北京” ;

2、声明方法

• 全局属性可以通过类名称直接访问
• static 定义一个“类方法”，也可以通过类名称直接访问。
• Person.setCountry("北京") ;

类方法和类属性的作用效果是一样的

class Person {
    private String name ;
    private int age ;
    private static String country = "石家庄" ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public static void setCountry(String c){
        country = c ;
    }
    public String getInfo(){
        return "姓名：" + this.name + "，年龄：" + this.age + "，城市：" + country ;
    }
}
public class StaticDemo03 {
    public static void main(String args[]){
    Person per1 = new Person("张三",20) ;
    Person per2 = new Person("李四",21) ;
    Person per3 = new Person("王五",22) ;
    System.out.println(per1.getInfo()) ;
    System.out.println(per2.getInfo()) ;
    System.out.println(per3.getInfo()) ;
    System.out.println("---------------------") ;
    Person.setCountry("北京") ;
    System.out.println(per1.getInfo()) ;
    System.out.println(per2.getInfo()) ;
    System.out.println(per3.getInfo()) ;
    }
}

3、static的使用注意

• static 本身声明方法或声明属性，但是在方法的访问上本身也存在着问题。
  1、 使用 static 声明的方法，不能访问非 static 的操作（属性或方法）
  2、 非 static 声明的方法，可以访问 static 声明的属性或方法

• 当一个实例化对象产生之后，可以调用所有的非 static 的操作，那么肯定也就可以调用所有的 static 操作。
  1、 如果说现在一个类中的属性或方法都是非 static 类型的，肯定是要有实例化对象才可以调用。
  2、 static 声明的属性或方法可以通过类名称访问，可以在没有实例化对象的情况下调用。

• 一个方法由主方法调用的格式：

public static 返回值类型 方法名称(参数列表){
    [return 返回值 ;]
}

4、static的应用

• static 的属性是所有对象所共同拥有的，那么就可以利用此特点完成一个自动命名的功能。

class Book {
    private String name ;
    private static int count = 0 ;
    public Book(){
        this.name = "无名字 - " + ++count ;
    }
    public Book(String name){
        this.name = name ;
    }
    public String getName(){
        return this.name ;
    }
}
public class StaticDemo06 {
    public static void main(String args[]){
        System.out.println(new Book("JAVA基础").getName()) ;
        System.out.println(new Book().getName()) ;
        System.out.println(new Book().getName()) ;
        System.out.println(new Book().getName()) ;
        System.out.println(new Book("Oracle").getName()) ;
    }
}

5、主方法的组成

• 主方法：是所有调用的起点，定义如下：

  • public static void main(String args[])

• 实际上每一个修饰符或参数都是有意义的：

  • public：表示外部都可以访问
  • static：方法可以由类直接调用
  • void：程序的起点，一旦开始了就没回头路
  • main：系统规定好的默认的方法名称
  • String args[]：是一个字符串数组，用于接收参数
  • 在主方法中，可以在一个程序运行时输入多个参数，每个参数之间使y用空格分隔，所有的参数都靠 String args[]进行接收。

public class Hello {
    public static void main(String args[]){
        for(int x=0;x<args.length;x++){
            System.out.println(args[x]) ;
        }
    }
}

但是，如果现在要想输入的参数中本身就包含了空格呢？通过双引号完成。
| - “hello world” “hello mldn”

• 主方法属于一切操作的起点 。所 以主方法将作为一个程序的客户端存在，那么客户端的操作代码越少越好。
• 在进行程序类的结构划分上，就一个原则：一个类只完成一个类的功能。

三丶代码块

• 在程序中使用“{}”括起来的一段代码就称为代码块，根据代码块出现的位置或声明的关键字的不同，分为四种：
  
  • 普通代码块：在一个方法中定义的代码块，称为普通代码块
  • 构造块：在一个类中定义的代码块
  • 静态块：使用 static 关键字声明的代码块
  • 同步代码块：
    // 从实际的开发来看，代码块的使用并不多。

1、普通代码块

public class CodeTest {
    public static void main(String args[]) {
        {  // 普通代码块
            int x = 10 ;
            System.out.println("x = " + x) ;
        }
        int x = 100 ;
        System.out.println("x = " + x) ;
    }
};

输出的结果是：

x=10;
x=100;

2、构造块

构造块是定义在一个类中的代码块。

class Demo {
    {
        System.out.println("构造块!!!") ;
    }
    public Demo(){
        System.out.println("构造方法!!!!") ;
    }
}
public class CodeTest01 {
    public static void main(String args[]) {
        new Demo() ;
    }
}

构造块会优先于构造方法执行，而且每当一个新的实例化对象产生时，都会调用构造块，会调用多次。

//构造块！！！
//构造方法！！！！

3、静态块

• 使用 static 关键字定义的代码块，而且静态块是定义在类中的。
  |- 在主类中定义的静态块将优先于主方法执行。
  |- 静态块优先于构造块执行，而且只执行一次。

class Demo {
    static{
        System.out.println("静态块！！") ;
    }
    {
        System.out.println("构造块！！！") ;
    }
    public Demo(){
        System.out.println("构造方法！！！！") ;
    }
}
public class CodeTest02 {
    static{
        System.out.println("主方法中的静态块。") ;
    }
    public static void main(String args[]) {
            System.out.println("--------------") ;
                new Demo() ;
    }
}

输出的结果是：

//主方法中的静态块。
//--------------
//静态块！！
//构造块！！！
//构造方法！！！！

四丶内部类

1、学习内部类，所需要认识的语法

○内部类就是指一个类【外部类】的内部还包含了另外的一个操作类【内部类】。
○被包含的类称为内部类，包含的类称为外部类。
|- 内部类可以方便的访问外部类中的私有成员。

class Outer {  // 定义外部类
    private String info = "Hello" ;
        class Inner {  // 定 定 义 内 部类 类
            public void print(){
                System.out.println(info) ; // 输 输出 出 info  属性
            }
    }
    public void fun(){
    new Inner().print() ;
    }
}
public class InnerDemo{
    public static void main(String args[]){
        new Outer().fun() ;
    }
}

|- 外部调用内部类，一定要先产生外部类的实例化对象，再产生内部类的实例化对象。

class Outer {  // 定义外部类
    private String info = "Hello" ;
        class Inner {  // 定义内部类
            public void print(){
            System.out.println(info) ;  // 输出 info 属性
            }
        }
}
public class InnerDemo01 {
    public static void main(String args[]){
        Outer.Inner in = null ; // 声明内部类的对象
        in = new Outer().new Inner() ;
        in.print() ;
    }
}

2 、使用static声明内部类

• 使用 static 声明了一个内部类：
  
  • 类将成为外部类。
  • 只能访问外部类中的 static 成员。

class Outer {  // 定义外部类
    private static String info = "Hello" ;
        static class Inner {  // 定义内部类，是 static 变为外部类
            public void print(){
            System.out.println(info) ;  // 输出 info 属性
        }
    }
}
public class InnerDemo02 {
    public static void main(String args[]){
        Outer.Inner in = new Outer.Inner() ;
        in.print() ;
    }
}

上述情况会有输出"Hello"

//当我们把方法不用static声明之后
private String info = "Hello" ;
//会报出下列错误
//无法从静态上下文中引用非静态 变量 info

3、在方法中 声明 内 部 类

• 一个内部类可以在任意的位置上声明
  |- 在方法中声明内部类的操作出现的是最多的。
  |- 在方法中定义的内部类，依然可以访问外部类中的属性，但是对于方法的参数，这个内部类是无法直接访问的，如果要访问，则在参数前面必须使用* final *关键字进行声明。

class Outer {
    private String info = "hello" ;
    public void fun(final int x){
        final int y = 100 ;
        class Inner {  // 方法中声明内部类
            public void print(){
                System.out.println(info) ;
                System.out.println("x = " + x) ;
                System.out.println("y = " + y) ;
            }
        }
        new Inner().print() ;
    }
}
public class InnerDemo03 {
    public static void main(String args[]){
        new Outer().fun(30) ;
    }
}

特此说明：
欢迎大家提出合理的意见。

最后再聊几句：
1、 this 关键字
|- this 关键字可以调用本类中的属性
|- 可以调用本类中的方法，但是如果要调用构造方法的话，则一定要放在构造方法的首行，且至少保留一个构造方法中没有使用 this 调用。
|- this 表示当前对象：当前操作类中方法的对象就是当前对象。
2、 引用传递的问题，可以使用引用表示出一些关系。
3、 链表基本上融合了类的设计、引用传递、构造方法、封装型、this 关键字。
4、 对象比较的时候实际上是将两个对象的每个属性进行比较，是一个类的内部自己所提供的功能。
5、 static 关键字
|- static 关键字声明的属性称为全局属性，为所有对象所共同拥有，可以直接通过类名称进行访问。
|- static 声明的方法可以直接由类名称调用，但是 static 的方法不能调用非 static 的操作，而非 static 的方法可以调用所有的 static 操作。
|- 主方法的组成。
6、 代码块（了解）。
7、 内部类的结构及各个操作必须掌握。
|- 使用 static 声明的内部类就是外部类。
|- 内部类可以在方法中声明，但是此时，要想访问方法中的参数，参数前必须加上final关键字。