黑马程序员——Java要点笔记——面向对象（二）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

day07 01-面向对象-构造函数-概述

1、构造函数特点：

（1）   函数名与类名相同

（2）   不用定义返回值类型

（3）   没有具体的返回值

2、构造函数：构建创造对象时调用的函数。作用： 可以给对象初始化。

day07 02-面向对象-构造函数-默认构造函数

1、创建对象都必须要通过构造函数初始化。

2、一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。如果要需要，那你自己再定义回来。如果自己定义了构造函数，一般都会再定义一个空参构造，防止用户使用出现问题。

day07 03-面向对象-构造函数-构造函数与一般函数的区别

1、一般函数和构造函数有什么区别呢？

答：构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

       一般函数：对象创建后，需要函数功能时才调用。

       构造函数：对象创建时，会调用，只调用一次。

       一般函数：对象创建后，可以被调用多次。

2、代码示例

public static void main(String[] args) {
       Person p=new Person();
       p.Person();//不是一般烂，是烂透了。构造函数的作用就是初始化
       p.speak();
       p.speak();
}

3、除了初始化之外，你再用对象去调用构造函数，java会报错。

public class Demo {
    int x=3;
    public static void main(String[] args) {
       Demo d=new Demo();
       d.Demo();
}

报错：

Exception in thread"main" java.lang.Error: Unresolved compilation problem:

    Themethod Demo() is undefined for the type Demo

    at com.itheima.Demo.main(Demo.java:12)

day07 04-面向对象-构造函数-重载

1、什么时候定义构造函数？

答：在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。比如人类的名字、性别。

2、代码示例：

public class Demo {
    public static void main(String[] args) {
       Person p=new Person();
       p.speak();
    }
}
class Person{
    String name=null;
    int age=0;
    Person(){
       name="baby";
       age=1;
    }
    public void speak(){
       System.out.println(name+"...."+age);
    }
}

以及：

public class Demo {
    public static void main(String[] args) {
       Person p=new Person();
       p.speak();
    }
}
class Person{
    public void speak(){
       String name="baby";
       int age=1;
       System.out.println(name+"...."+age);
    }
}

       以上两者都可以在调用speak方法的时候实现同一结果：baby….1

       有何不同？

       第二个之后在调用speak方法的时候，这个对象才有姓名、年龄。如果让他做其他事情的时候，他就没有姓名、年龄。这样不合适。

day07 05-面向对象-构造函数-内存图解

1、分析以下一段代码的内存图解：

class Person{
  String name=null;
  int age=0;
  Person(Stringn,int a){
     name=n;
     age=a;
  }
}

Person p=new Person("小强"，10);

       p.speak();

先开辟一块堆内存。

       调用构造函数，构造函数进栈。name=n age=a，他在栈中，无name与age，去堆里找。

构造方法遇到return，弹栈。这时main方法中的p才有了指向。这时Person p=new Person("小强"，10);中等号右边的内容才算结束。结束之后p才有了指向。

3、即使你没有定义构造函数，在实例化对象时，构造函数也会进栈。初始化对象，必须会调用一个构造函数，他不进栈，你怎么初始化？！

day07 06-面向对象-构造函数-细节

1、

构造函数与setter方法有何区别？

答：两者不矛盾。一个用来初始化对象，一个用来做后期更改。就像一个人生下来叫“旺财”，后来改名字了，叫“旺旺”，这个就用setter方法改。不然，你每次都用构造方法，这不要投胎了么。

2、回答以下两个问题：

Person()

{……}

Public void speak()

{……}

（1）   Person()中能调用speak()吗？

可以。

（2）   speak()中能调用Person()吗？

不能！Person只用于初始化，只在new对象的时候调用一次。

4、Person(){……}

void Person(){……}//加了void之后，这个函数就不是构造函数了，但你也不能说他错。

5、写一般函数，第一个单词首字母小写，构造函数首字母大写（因为类名第一个单词首字母大写，与类名一致）

6、定义完有参构造后，无参构造自动消失，你需要的话自己再手动定义一个。

7、构造函数中有return语句吗？

答：有！return用来结束函数的，所有函数都有return，你不写他也有。所有函数全有return，return后面不跟任何东西的话，起结束函数的功能。

8、分析以下代码的运行结果：

public class Demo {
    public static void main(String[] args) {
       Person p=new Person();
       p.Person();
    }
}
class Person{
    Person(){
       System.out.println("构造");
    }
    void Person(){
       System.out.println("普通");
    }
}

运行结果：构造

                 普通

day07 07-面向对象-this关键字-使用场景1-&this原理图解

1、this到底代表啥？

       this代表对象，代表哪个对象呢？

代表当前对象。

this就是所在函数，所属对象的引用。this是一个引用！

简单来说，哪个对象调用了this所在的函数，this就代表哪个对象。

2、this原理图解

public class Demo05 {
    public static void main(String[] args) {
       Person p=new Person("旺财");
       p.speak();
    }
}
class Person{
    String name;
    int age;
    Person(String name){
       this.name=name;
    }
    void speak(){
       System.out.println("名字是："+name+"年龄是："+age);
    }
}

       个人觉得，this并不完全等于p。this先于p有指向。因为构造函数未完成时，p还没有指向，但是this可用。

都省略了this。其实this被隐含了，但是若像上面name=name；出现了歧义，Java不知道给谁加this了，或者要不要加this了。这时，就需要你手动加，来告诉java哪个是堆里成员变量，哪个是局部变量。

3、参数列表中的name是局部变量，this.name是通过this这个引用找到了对应堆内存中的成员变量name。

day07 08-面向对象-this关键字-使用场景2-以及细节

1、构造函数可以调用一般函数。一般函数不能调用构造函数。那么构造函数与构造函数之间如何访问呢？

2、

3、  图解

public class Demo05 {
    public static void main(String[] args) {
       Person p=new Person("旺财",20);
       p.speak();
    }
}
class Person{
    String name;
    int age;
    Person(String name){
       this.name=name;
    }
    Person(String name,int age){
       this(name);
       this.age=age;
    }
    void speak(){
       System.out.println("名字是："+name+"年龄是："+age);
    }
}

    

   方法会先从自己的栈内存中找name，找不到再到堆中去找。若在自己的栈中找到了，出现了歧义，我加上一个this，让他强制去找堆中的成员变量。

4、  this的使用场景2：this也可以用于在构造函数中，调用其他构造函数。（构造调用构造时才用）

5、  注意①：这种情况，this只能定义在构造函数的第一行！因为初始化动作要先执行。

6、  解释注意①：

7、  注意②：this()调用防止死循环调用，要记得留一个出口。

不留出口，会导致程序停下来，因为栈内存溢出了。无穷无尽的进栈，无人出栈。

day07 09-面向对象-this关键字-应用

1、this经典应用：可用this判断是否是同龄人。判断两个对象是否相等。

2、该代码方法应该只有一个参数。我与张三比，我有compare这个功能，你再把我作为参数搞进去干啥。而应该是由我来调用这个方法，把你张三作为参数传进来。

3、代码：

public boolean compare(Person p){
       return this.age==p.age;
}

day07 10-面向对象-static关键字-数据共享

1、static本身是一个关键字，也是一个修饰符。他可以修饰成员变量、成员函数、内部类。

2、示例：

class Person{
    String name;
    String country="CN";
    public void show(){
       System.out.println(country+";"+name);
    }
}
public class Demo06 {
    public static void main(String[] args) {
       Person p=new Person();
       p.name="小强";
       p.show();
    }
}

day07 11-面向对象-static关键字-特点

1、static修饰的内容，可被类名直接调用。

2、那我全静态不就好了，还省的写对象。这种思想对吗？

错误！你static name为小强。那所有的人类都得叫小强吗？明显不行！

3、  static的特点

①static是一个修饰符，用于修饰成员。（成员变量和成员方法）

②static修饰的成员被所有的对象所共享。

③static优先于对象存在，因为static的成员随着类的加载就已经存在了。

④static修饰的成员多了一种调用方式，就是可以直接被类名所调用。

⑤static修饰的数据是共享数据，对象中存储的是特有数据。

day07 12-面向对象-static关键字-成员变量和静态变量的区别

1、成员变量和静态变量的区别

①两个变量的生命周期不同

              成员变量随着对象的创建而存在，随着对象的被回收而释放。

              静态变量随着类的加载而存在，随着类的消失而消失。类在，静态变量就一直在。

②调用方式不同

              成员变量只能被对象调用。

              静态变量可以被对象调用，也可以被类名调用。

③别名不同

              成员变量也称为实例变量。

              静态变量也称为类变量。

④数据存储位置不同

              成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。

              静态变量数据存储在方法区（共享数据区）的静态区中，所以也叫对象的共享数据。static所修饰的变量被多个对象所共享。

3、  代码示例：

public class TestDemo08 {
    public static void main(String[] args) {
       Person per1=new Person();
       per1.talk();
       per1.country="JP";
       per1.talk();
       Person per2=new Person();
       per2.talk();
    }
}
class Person{
    int age=10;
    static String country="CN";
    void talk(){
       System.out.println("age:"+age+"_country:"+country);
    }
}

    运行结果：

    age:10_country:CN

    age:10_country:JP

    age:10_country:JP

    虽然只是per1将country从CN改成了JP，但由于country是共享数据，per2打印出来的也是JP。

day07 13-面向对象-static关键字-注意事项

1、静态使用的注意事项（静态的使用，绝对不牵涉到事先要有对象，不牵涉到堆内存，也就不牵涉到this、super这些引用指向）

①静态方法只能访问静态成员（非静态既可以访问静态，又可以访问非静态）。这成员包含两部分，一个是变量，一个是函数。

       因为静态不用对象，而非静态成员在对象的创建时才会出现。

②静态方法中不可以使用this或者super关键字。

       this、super可以调用构造函数，所以不行。this代表对象的堆内存地址。

③主函数是静态的。

2、代码示例

3、代码示例

public class TestDemo09 {
    public static void main(String[] args) {
       Person.talk();
    }
}
class Person{
    int age=10;
    static String country="CN";
    static void talk(){
       Person per=new Person();
       System.out.println("age:"+per.age+"_country:"+country);
    }
}

    运行结果：age:10_country:CN

       静态方法talk()，通过对象调用非静态变量age完全没有问题（主方法其实也类似）。

4、代码示例

    public static void main(String[] args) {
       int x=0;
       System.out.println(x);
    }

    ok。与静态方法只能调用静态变量不矛盾。这里说的调用，你在内部定义，再用它不算调用。在静态方法中new对象去调用也没关系。

day07 14-面向对象-static关键字-main函数解析

1、public static void main(String[]args)

2、主函数的特别之处：①、格式是固定的②、被jvm所识别和调用。

3、public：因为全县必须是最大的

4、static：不需要对象的，直接用主函数所属类名调用即可。

5、void：主函数没有具体的返回值

6、String[]  args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

7、args只是一个名字

public static void main(String[] x)都OK。

8、public static void main(String[]args)

   public static void main(String[] x)

       挂了，到底哪个是入口？JVM无法分清。

9、

    public static void main(String[] args) {
       int x=0;
       System.out.println(x);
    }
    public static void main(int x) {
       int z=1;
       System.out.println(z);
    }

运行结果：0

       可见，虽然有重载，但是java仍然从main(String args[])处开始。

day07 15-面向对象-static关键字-内存图解

1、代码示例

class Person{
    private String name;
    private int age;
    static String country="CN";
    public Person(String name,int age){
       this.name=name;
       this.age=age;
    }
    public void show(){
       System.out.println(Person.country+";"+this.name+";"+this.age);
    }
    public static void method(){
       System.out.println(Person.country);
    }
}
public class TestDemo11 {
    public static void main(String[] args) {
       Person.method();
       Person p=new Person("java",20);
       p.show();
    }
}

2、

       全部搞完后，main方法最后有return，main方法弹栈。

3、代码示例：

public class TestDemo12 {
    public static void main(String[] args) {
       Person per=new Person();
       per.talk();
       Dog d=new Dog();
       d.talk();    
    }
}
class Person{
    static String name="人";
    public void talk(){
       System.out.println(name);
    }
}
class Dog{
    static String name="狗";
    public void talk(){
       System.out.println(name);
    }
}

运行结果：人

                狗

       Person类中定义的static变量只对这个类的对象有用。static变量是被给雷的对象来共享的。

day07 16-面向对象-static关键字-什么时候用

1、静态（static）什么时候用？

①静态变量

       （不加静态在堆内存的对象中，加了静态在方法区中。不加静态，对象特有；加了静态，对象共有）静态变量放置内存浪费，不用在每个对象中都去定义，我只定义一个，归这个类所有的对象共有。

       当分析对象中所具备的的成员变量的值都是相同的。这时这个成员就可以被静态修饰（对象特有跟对象共有的区别）。

       只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中。（你要是全静态，就意味着不是共性的数据，也被共性了）定义成静态的。

②静态函数

       （我对外提供的函数，到底是静态的呢，还是非静态的呢？）看他调用的数据类型。

       函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。

       简单点说。从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态的。

       但是非静态需要被对象调用，而仅创建对象调用非静态的，没有访问特有数据的方法，该对象的创建是没有意义的。（非静态不需要对象，直接用类名调用即可）

day07 17-面向对象-static关键字-静态代码块

1、static{……}直接写在类中。

2、静态代码块，随着类的加载而执行，类只要一加载，就执行这个代码块。

3、静态代码块的作用：用于给类初始化。

       有些类，是没必要创建对象的。例如类中成员皆静态，我创建这个类的对象就没意义了。那我不创建对象，就不能调用构造函数，那我咋初始化。答：用静态块给类初始化。但这种初始化方式用的不多。

4、如果静态块写到了主类中呢？

public class TestDemo13 {
    static{
       System.out.println("a");
    }
    public static void main(String[] args) {
       System.out.println("b");
    }
}

运行结果：a

                b

       可见，这里仍然先执行静态块，之后再执行主方法。主类一旦被创建，静态块就没执行了。

day07 18-面向对象-构造代码块

1、直接定义在类里面的代码块——构造代码块

2、构造代码块的作用：给该类的所有对象初始化。某部分相同的初始状态，但后期对象仍可以修改成自己各自独特的属性。

3、构造函数是给对应的对象进行针对性的初始化。