Java编程之“对象与类”

        前言：本章节会简单介绍一下Java中的类和对象。众所周知，Java与C/C++之间比较大的区别在于Java是面向对象编程，C是面向过程编程，虽然C++有面向对象编程，但是它不完全。基于此本文将会对 ：何为面向对象编程？类和对象起到什么作用？对象如何构造？等一系列问题进行详细说明，希望能对你有所帮助

目录

一、面向对象编程设计概述

二、类（重点）

1. 何为类

2.类的定义与实例化 

3.修饰符 

4.static关键字

5.匿名对象

6.小结 

三、 补充说明:

1.封装：private实现封装 

2. 认识代码块

---

一、面向对象编程设计概述

        面向对象编程的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分

       
       举一个简单的例子，想要实现一个Wed浏览器可能需要大约2000个过程，这个过程可能需要对全局数据进行操作，但是如果采用面向对象的风格去设计程序，可能只需要100个类，每个类20个方法，虽然都一样是2000，but大问题被分开来了，我可以根据具体问题去对应的类上找BUG，这样的代码更便于管理。

二、类（重点）

1. 何为类

        类（class）是构造对象的模板或者蓝图，由类构造对象的过程叫做创建类的实例。

        在Java里面万物皆对象，简单例子来帮助理解，定义一个human类，这个类里面给人配置了属性（变量、常量），会什么技能（方法），但这也只是一个对human的定义

public class Human{
    public static void main(String[] args){
        Human human = new Human();  
    }
    void run(){
    
    }
    void eat(){
    
    }
    void study(){
        
    }
    ........
}

2.类的定义与实例化 

        1)类的定义都是同一个语法，“class+类名字（首字母大写）” 下面就是类的创建样例

class Person {
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {//成员方法
       System.out.println("吃饭!");  
   }
    public void sleep() {
       System.out.println("睡觉!");  
   }
}

        2)new 关键字来进行创建类实例，用 "." 就是调用类内部定义的方法。

public class Human{
    public static void main(String[] args){
        Human human = new Human();      //公共类实例
        Person person = new Person();   //普通类实例
        person.eat();
        person.sleep();
    }
    void run(){}
}
class Person {
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {//成员方法
       System.out.println("吃饭!");  
    }
    public void sleep() {
       System.out.println("睡觉!");  
    }
}

        由上面的样例可以看到，new 实例的时候，都是这一个语法： 类名+变量名+赋值+new+类的构造器 

         3) 构造器 ： 一个类可以有多个不同的构造器

        构造器的任务就是构造出这个类，但是同类之间可以存在差异，构造器的语法就和创建方法一样，只是没有返回值，“public +className +（）”

class Person {
    //成员属性 实例变量
    public int age;
    public String name;
    public String sex;
    //构造器一
    public Person(){
        
    }
    //构造器二
    public Person(int age , String name , String sex){
           this.age = age;
           this.name = name;
           this.sex = sex;
    }
    public void eat() {//成员方法
       System.out.println("吃饭!");  
    }
    public void sleep() {
       System.out.println("睡觉!");  
    }
}

        第一个构造器是默认的，假如你的类内没有定义任何构造器，程序会自己帮你建立。
        第二个构造器是带参数的，给定义的属性进行赋值，当参数的类型和名都与定义的变量相同时，要使用 this 关键字 来调用代码块外部的变量来进行接收，这个关键字是当前类本身的引用

         对于多个同时存在的，不同名字同类型不同参数的方法或者构造器，我们把它这个行为叫做： 重载（overloading）

3.修饰符 

        访问权限修饰符：public、private、protected、default ( 功能顾名思义)

修饰符	同一个类	同一个包	子类	任何地方
public	yes	yes	yes	yes
private	yes
protected	yes	yes	yes
default	yes	yes

4.static关键字

       一个成员或者方法被static修饰的时候，我们不需要创建类再去调用这个方法，可以直接”.“应用，

public class Person {
	public int age;
	public String name;
	public static void main(String[] args) {
		Person.run();
//		p.run();
	}
	public static void run() {
		
	}
}

        如果你在创建对象后引用内部的static 方法也可以，运行不会报错，但是会有一个提示说 ：最好还是通过static的方式来调用static方法。

       再有，static修饰后就是这个东西就是属于类的而不是属于对象的 ， 类比于某件东西属于大家共有的财产，而不是个人私有的。

        被static修饰的变量会有默认值，int、double、float类型默认为0，boolean默认为false，类默认为null.   

public class demo{

    static double i;
    static int j
    static boolean k;

    public static void main(String[] args){

        System.println(i);    //打印0
        System.println(j);    //打印0   
        System.println(k);    //打印false

    }
}

        我们来看下面这个程序来理解一些static的执行

class TestDemo{
    public int a;
    public static int count; }
public class Main{
    
 public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo.count);
        System.out.println("============");
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo.count);
   }
}
//结果
1
1
============
1
2

5.匿名对象

        匿名只是表示没有名字的对象.

        1）没有引用的对象称为匿名对象.

        2）匿名对象只能在创建对象时使用.

        3）如果一个对象只是用一次, 后面不需要用了 , 可以考虑使用匿名对象.        

public class Person {
	public int age;
	public String name;
	public static void main(String[] args) {
        new Person();
	}
}

6.小结代码

class Person {
    public int age;//实例变量   存放在对象内
    public String name;//实例变量
    public String sex;//实例变量
    public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
    public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
    public static final int  COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更
改
    //实例成员函数
    public void eat() {
       int a = 10;//局部变量
       System.out.println("eat()!");  
   }
    //实例成员函数
    public void sleep() {
       System.out.println("sleep()!");  
   }
    //静态成员函数
     public static void staticTest(){
         //不能访问非静态成员
        //sex = "man"; error
        System.out.println("StaticTest()");
     }
}
public class Main{
 public static void main(String[] args) {
        //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null
        //System.out.println(person.count);//会有警告!
        //正确访问方式：
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
        person.eat();
        person.sleep();
 }
}

三、 补充说明:

1.封装：private实现封装 

什么叫封装?

        <<代码大全 >> 开篇就在讨论一个问题 : 软件开发的本质就是对程序复杂程度的管理 . 如果一个软件代码复杂程 度太高, 那么就无法继续维护 . 如何管理复杂程度 ? 封装就是最基本的方法 .

在我们写代码的时候经常会涉及两种角色 : 类的实现者 和 类的调用者 .

        封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了 .

        这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度 

        1)被 public 修饰的成员变量或者成员方法 , 可以直接被类的调用者使用 .

        2)被 private 修饰的成员变量或者成员方法 , 不能被类的调用者使用

        

        对于封装我们要视情况而定，对于能公开的就public，不能公开或者说对于调用者来说不关心的就private封起来。

        举个例子：

        1）直接使用 public

class Person {
 public String name = "张三";
 public int age = 18; }
class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
   }
}
// 执行结果
//我叫张三, 今年18岁

        a.这样的代码导致类的使用者(main 方法的代码 ) 必须要了解 Person 类内部的实现 , 才能够使用这个类 . 学习成本较高

        b.一旦类的实现者修改了代码 ( 例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码 , 维护成本较高

        2）使用private封装属性

class Person { 
 private String name = "张三"; 
 private int age = 18; 
 
 public void show() { 
 System.out.println("我叫" + name + ", 今年" + age + "岁"); 
 } 
} 
class Test { 
 public static void main(String[] args) { 
 Person person = new Person(); 
 person.show(); 
 } 
} 
// 执行结果
//我叫张三, 今年18岁

        a.此时字段已经使用 private 来修饰 . 类的调用者 (main 方法中 ) 不能直接使用 . 而需要借助 show 方法 . 此时类的使 用者就不必了解 Person 类的实现细节 .

        b.同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改 ( 类的调用者根本访问不到 name, age这样的字段 )

2. 认识代码块

        1）什么是代码块

        使用 {} 定义的一段代码 .

根据代码块定义的位置以及关键字，又可分为以下四种：

        a. 普通代码块

        b. 构造块

        c. 静态块

        d. 同步代码块（多线程，本文不提）

        2）普通代码块

普通代码块：定义在方法中的代码块

public class Main{ 
     public static void main(String[] args) { 
         { //直接使用{}定义，普通方法块
             int x = 10 ; 
             System.out.println("x1 = " +x); 
         } 
         int x = 100 ; 
         System.out.println("x2 = " +x); 
     } 
} 
// 执行结果
x1 = 10 
x2 = 100

        3）构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量 

class Person{ 

     private String name;//实例成员变量
     private int age; 
     private String sex; 
 
     public Person() { 
         System.out.println("I am Person init()!"); 
     } 
 
     //实例代码块
     { 
         this.name = "bit"; 
         this.age = 12; 
         this.sex = "man"; 
         System.out.println("I am instance init()!"); 
     } 
 
     public void show(){ 
         System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
     } 
 } 
public class Main { 
     public static void main(String[] args) { 
         Person p1 = new Person(); 
         p1.show(); 
     } 
} 
// 运行结果
I am instance init()! 
I am Person init()! 
name: bit age: 12 sex: man

        3）静态代码块 

使用 static 定义的代码块。 一般用于初始化静态成员属性。

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

静态代码块执行完毕后 , 实例代码块（构造块）执行，再然后是构造函数执行。

class Person{ 

     private String name;//实例成员变量
     private int age; 
     private String sex; 
     private static int count = 0;//静态成员变量 由类共享数据 方法区
 
     public Person(){ 
         System.out.println("I am Person init()!"); 
     } 
 
     //实例代码块
     { 
         this.name = "bit"; 
         this.age = 12; 
         this.sex = "man"; 
         System.out.println("I am instance init()!"); 
     } 
 
     //静态代码块
     static { 
         count = 10;//只能访问静态数据成员 
         System.out.println("I am static init()!"); 
     } 
 
     public void show(){ 
         System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
     } 
 
} 
public class Main { 
     public static void main(String[] args) { 
         Person p1 = new Person(); 
         Person p2 = new Person();//静态代码块是否还会被执行？
     } 
}