java基础知识--对象与类

5.01 面向过程与面向对象

面向对象是基于面向过程的编程思想

面向过程：面向过程的思想是把一个项目、一件事情按照一定的顺序，从头到尾一步一步地做下去，先做什么，后做什么，一直到结束。这种思想比较好理解，其实这也是一个人做事的方法。

面向对象：面向对象的思想是把一个项目、一件事情分成更小的项目，将其分配给别人做，你只需要最终下命令使用。

举例：

用面向过程就等于是要先自己制造一台电视，然后再收看节目；
而面向对象则是直接去商店买一台电视收看。

面向对象的数据是封装在对象内部，而面向过程的则不是。
面向对象的概念更能描述现实世界，任何物体都是对象，而面向过程则比较麻烦。

面向对象开发，就是不断地创建对象，使用对象，指挥对象做事情
面向对象设计，其实就是在管理和维护对象之间的关系
面向对象特征，封装，继承，多态

5.02 类与对象

对象：

对象是类的一个实例，有状态和行为。
软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。
方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。
例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

对象的内存图解：

class Demo1{
 public static void main(String []args){
        Dog d= new Dog( ); 
        d.printDog();
     }
public class Dog{
	String name;
	int age=3;
	public Dog(){
	name="aHuang";
	age=5;
	}
    public printDog(){ 
        System.out.println("小狗的名字是 : " + name );
     }    
 }

类：

类是一个模板，它描述一类对象的行为和状态。类可以看成是创建Java对象的模板。

 public class Dog{
    String breed;
    int age;
    String color;
    void barking(){
    
    }   
    void hungry(){
    
    }  
   void sleeping(){
   
   }
 }

一个类可以包含以下类型变量：

局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：

成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：

类变量也声明在类中，方法体之外，但必须声明为static类型。

一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。
　　
5.03 成员变量和局部变量的区别

存储位置

成员变量 在堆内存中对象的所属空间里
局部变量 在栈内存中函数的所属空间里

生命周期

成员变量 随着对象的创建而创建 随着对象的消亡而消亡
局部变量 随着函数的进栈而存在 随着函数的弹栈而消失

初始化

成员变量 有默认初始化 可以直接通过对象调用
局部变量 必须在初始化且赋值后 再调用

作用域：

成员变量 一般而言全局使用
局部变量 只能在当前函数中使用

5.04 形式参数的分类

基本数据类型

传值（传常量在常量池中的地址）
在方法中运行完成后返回给调用者时 其值不会发生改变

引用数据类型

传址（对象在堆中的地址）
在方法中运行完成后返回给调用者时 地址中的值也会改变

5.05 匿名对象

匿名对象就是没有名字的对象：

Student stu = new Student();//这个stu就是对象，名字就是stu

new Student();//这个也是一个对象，但是没有名字

例子

普通申明一个对象是这样的
A a = new A();
那么这个时候a就是类A的一个对象，这个对象名字就是a
method(A a);
整理method是一个方法，他需要传递一个对象来作为参数，那么这个时候有2种方法：
方法1：
A a =new A();
method (a);

方法2：
method (new A());
方法2中new A()就是一个匿名对象，他没有名字。

匿名对象的两种使用情况：

对象调用方法仅仅一次的时候
作为实际参数传递

5.06 封装概述

是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

封装原则：

将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共方法对其访问

实现封装的步骤：

1. 修改属性的可见性来限制对属性的访问（一般限制为private）
2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问。

public class Person{
    private String name;  //限制对属性的访问
    private int age;
​
    public int getAge(){  //提供对外的公共方法访问
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

5.07 private关键字

private关键字是一个权限修饰符，可以修饰成员，被修饰的成员只在本类中才能访问。

类中所有数据域都是私有的，外界可以间接访问：提供任何一个数据域的setXxx()方法。提供返回该引用类型变量的getXxx()方法。

public static void main(String[] args) {
     Test t = new Test(5, "ABC", new Date());
     System.out.println(t.toString())；
     String s = t.getStr();   //获取引用类型的数据域，其中Date是可变的
 }
 public class Test {
   private int a = 5;
   private String str; //String是不可变对象，它的方法都是返回一个新的String对象
   private Date date;
   public Test(int a, String str, Date date) {
     super();
     this.a = a;
     this.str = str;
     this.date = date;
   }
   public int getA() {
     return a;
   }
   public String getStr() {
     return str;
   }
 }

5.08 this关键字

关键字this表示当前对象，引用对象自身。 可以用于访问实例的数据域， 尤其是实例变量和局部变量同名时，进行分辨。除此之外，可以在构造方法内部调用同一个类的其他构造方法。

实例变量和局部变量

class Test{
	public int a;
	public String str;
	public TestThis(int a, String str) {
	    super(); 
	    this.a = a;   //传入的值给类中成员变量a
	    this.str = str;   //传入str变量所存的地址给类中成员变量str
	}
}

构造函数调用构造函数

public int a;
   public int b;
   public int c;
   public TestThis(int a, int b) {    //构造方法1
       this(a, b，0);  //调用构造方法2来简化初始化操作
   }
   public TestThis(int a, int b, int c) {    //构造方法2
       this.a = a;  
       this.b = b; 
       this.c = c;
   }

图解：

5.09 构造函数

构造函数 ，是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

构造函数格式

1.函数名必须为类名
2.没有返回值类型,没有返回值
3.没有返回值类型不代表没有return
4.可以有权限修饰符
5.函数有参数列表，所以可以重载
6.当没有定义任何构造函数时 会存在一个默认无参且隐藏的构造函数
7.如果一旦定义任何构造函数，则默认的不存在
8.永远将无参构造函数定义出来
9.有了构造函数 还是是否需要set get 看数据今后是否仍需修改

public class Dog{
     public Dog(){
     
     }  
     public Puppy(String name){
        name="tuoxie";
     }
 }

构造方法注意事项：

如果程序员不写构造函数，系统会给出默认构造函数
如果程序员提供了构造函数，系统将不再提供默认构造函数
构造函数也是可以重载的
构造函数是有return语句的
建议永远自己给出无参构造函数

5.10成员变量赋值步骤：

隐式初始化–>显式初始化–>针对性初始化–>后期修改值

5.10 成员函数划分

定义在类中的方法称之为成员方法。

根据返回值：

有明确返回值
返回void类型的函数

根据形式参数

无参函数
带参函数

5.11构造函数与成员函数区别

1.构造函数没有返回值 成员函数有
2.构造函数只有在创建对象时使用且执行一次
  成员函数是在对象创建之后 任意次数调用
3.成员函数不能调用构造函数
4.构造函数能调用成员函数（封装了构造函数中的代码，一般不会被外界调用）
5.构造函数能调用构造函数
	this调用构造函数只能在第一句
	对this的调用必须是构造器中的第一个语句
	构造函数之间的调用不能产生环路！！！

5.11 对象的创建流程和访问

创建流程：

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

代码中：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。

运行程序时：

1. 加载字节码文件
2. 在栈内存中开辟引用变量空间
3. 在堆内存中开辟对象空间
4. 对对象的成员进行默认初始化
5. 对对象的成员进行显式初始化
6. 构造函数进栈对对象成员进行针对性初始化
7. 构造函数弹栈，对象创建完毕
8. 将对象的地址赋予引用变量

class Demo1{
 public static void main(String []args){
        Dog d= new Dog( "tom" );  // 下面的语句将创建一个Dog对象
     }
public class Dog{
	String name;
	int age=3;
	public Dog(){
	name="aHuang";
	age=5;
	}
    public printDog(String name){ 
        System.out.println("小狗的名字是 : " + name );  //这个构造器仅有一个参数：name
     }    
 }

访问：

通过已创建的对象来访问成员变量和成员方法，如下所示：

ObjectReference = new Constructor();    /* 实例化对象 */
ObjectReference.variableName;    /* 访问其中的变量 */
ObjectReference.MethodName();   /* 访问类中的方法 */

5.12 成员变量注意事项

变量什么时候定义为成员变量：

如果这个变量是用来描述这个类的信息的，那么该变量就应该定义为成员变量

变量到底定义在哪里：

变量的范围越小越好，因为能及时的被回收

5.13 static关键字

1)static变量

static变量也称作静态变量。

静态变量和非静态变量的区别是：

静态变量被所有的对象所共享(类所拥有），在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。
非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进行初始化。
2）static 方法

static方法一般称作静态方法，静态方法不依赖于任何对象就可以进行访问。主要看方法是否直接访问，成员(成员变量 成员函数)，如果没有 该方法可以定义为静态方法。

（1）对于静态方法来说，是没有this的。因为它不依附于任何对象，既然都没有对象，就谈不上this了。
（2）在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
（3）虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static

3）static代码块

static关键字有一个作用就是 用来形成静态代码块以优化程序性能。

static块可以置于类中的任何地方，类中可以有多个static块。
在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次

class Person{
    private Date birthDate;
    private static Date startDate,endDate;
    static{  //静态代码块
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }
     
    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }
     
    boolean isBornBoomer() {
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}

因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

static关键字特点

随着类的加载而加载
优先于对象存在
被类的所有对象共享（这也是我们是否使用静态关键字的判断条件）
可以通过类名调用

注意事项：

（1）static是不允许用来修饰局部变量。
（2）静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
（3）static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字。

5.14 静态变量和成员变量的区别

1.存储位置

静态变量 在静态方法区
成员变量 在堆内存中对象的所属空间里

2.生命周期

静态变量随着类的加载而存在，随着程序的结束而消失
成员变量随着对象的加载而存在，随着对象的消亡消失

3.调用方式

静态变量可以类直接调用，也可以对象调用
成员变量只能先创建对象，再用对象调用

4.所属

成员变量所属于对象 实例变量 对象的特有属性
静态变量所属于类   类变量   对象的共享属性

5.15 final关键字

(1）修饰类

修饰类当用final去修饰一个类的时候，表示这个类不能被继承。

注意：
a. 被final修饰的类，final类中的成员变量可以根据自己的实际需要设计为fianl。

b. final类中的成员方法都会被隐式的指定为final方法。

(2）修饰方法

被final修饰的方法不能被重写。

注意：

a. 一个类的private方法会隐式的被指定为final方法。

b. 如果父类中有final修饰的方法，那么子类不能去重写。

(3） 修饰局部变量

a.边定义边赋值之后 不可修改值
b.先定义 再赋值 之后不可修改值

注意：

a. 必须要赋初始值，而且是只能初始化一次。

(4） 修饰成员变量

a.只有默认初始化 报错 后期也不可修改
b.有显示初始化 后期不可修改
c.有显示初始化 有针对性初始化(不可修改) 报错
d.无显示初始化 有针对性初始化 后期不可修改

注意：

a. 必须初始化值。

b. 被fianl修饰的成员变量赋值，有两种方式：1、直接赋值 2、全部在构造方法中赋初值。

c. 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。

d. 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。

5.16 小结

1）类是对象的模板。它定义对象的属性，并提供用于以创建对象的构造方法以及操作对象的普通方法。

2）类也是一种数据类型。可以用它声明对象引用变量。对象引用变量中存放的是该对象的引用。严格地讲，对象引用变量和对象是不同的，但是大多数情况下，它们的区别是可以忽略的。

3）对象是类的实例。可以使用 new 操作符创建对象，使用点搡作符（ .）通过对象的引用变量来访问该对象的成员。

4）实例变量或方法属于类的一个实例。它的使用与各自的实例相关联。
   静态变量是被同一个类的所有实例所共享的。可以在不使用实例的情况下调用静态方法。
   
5）类的每个实例都能访问这个类的静态变量和静态方法。
  为淸晰起见，最好使用 “类名 .变量”和 “类名 .方法" 来调用静态变量和静态方法。
  
6）可见性修饰符指定类、方法和数据是如何被访问的。
  公共的（ public)类、方法或数据可以被任何客户访问，
  私有的（private)方法或数据只能在本类中被访问。
  
7）可以提供 get (访问器）方法或者 set (修改器）方法使客户程序能够看到或修改数据。

8）get 方法具有方法签名 public returnType getPropertyName（）。
如果返回值类型（ returnType)是boolean 型，则 get 方法应该定义为 public booleanisPropertyName（）。
set 方法具有方法签名 public void setPropertyName(dataType propertyValue),,

9）所有传递给方法的参数都是值传递的。对于基本类型的参数，传递的是实际值；而若参数是引用教
据类型，则传递的是对象的引用。

10）Java 数组是一个可以包含基本类型值或对象类型值的对象。当创建一个对象数组时，它的元素被
賦予畎认值 null。

11）一旦被创建，不可变对象就不能被改变了。为了防止用户修改一个对象，可以定义该对象为不可变类。

12）实例变量和静态变量的作用域是整个类，无论该变量在什么位置定义。实例变量和静态变量可以在类中的任何位置定义。

13）this 关键宇可以用于引用进行调用的对象。它也可以用于在构造方法中来调用同一个类的另外一个构造方法。