java Day5-7

最新推荐文章于 2024-05-09 00:07:29 发布

slny

最新推荐文章于 2024-05-09 00:07:29 发布

阅读量152

点赞数

本文链接：https://blog.csdn.net/weixin_44102380/article/details/88978633

版权

Day 5

构造函数：在类中中建立一个与类的相同名字的函数，该函数在对象一被调用的时候立即运行。
在没有构造函数的对象中，系统会默认给该类加入一个空参数的构造函数。
构造函数和一般函数的不同：构造函数在对象建立后就立即执行，一般函数需要调用，构造函数仅执行一次，一般函数可以多次调用。

class demo
{
    demo ()
    {
        System.out.println("i am demo!");
    }
}
class why
{
    public static void main(String[] args)
    {
        demo pp=new demo();
    }
}

构造代码块，在类中构造一块代码，构造代码块优先于构造函数执行，作用是给类中的每一个对象进行初始化，当类中的不同对象有相同的特性时可以使用。对象一建立就立即运行。

class demo
{
    {
        System.out.println("this is a code block~");
    }
    demo ()
    {
        System.out.println("i am demo!");
    }
    demo (int n)
    {
        System.out.println("i am demo"+n);
    }
}
class why
{
    public static void main(String[] args)
    {
        demo pp=new demo();
        demo pp1=new demo(2);
    }
}

构造代码块

this关键字：解决函数中的同名变量，this代表所在函数所属对象的引用。哪个对象调用函数，this就代表哪个对象。

class demo
{
    String name;
    int age;
    demo (String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public boolean compare2(demo p)
    {
        return this.age==p.age;
    }
}
class compare
{
    public static void main(String[] args)
    {
        demo p1 = new demo("zhangsan", 25);
        demo p2 = new demo("lisi", 25);
        boolean b = p1.compare2(p2);
        System.out.println(b);
    }
}

类中包括人的姓名和年龄，比较函数比较两个对象的年龄是否相等。
运行结果为 ture；
this语句可以在构造函数之间调用，但必须放在第一行。

Day 6

Static 关键字：是一个修饰符，用于修饰成员，用于对象中有相同信息时，当成员被Static修饰后，可以直接通过类名来调用这个成员。

class demo
{
    static String word = "no matter who you are, you always tyr hart to live";
}
class day6
{
    public static void main(String[] agrs)
    {
        System.out.println(demo.word);
    }
}

Static

类变量和实例变量的区别

存放位置：类变量存在在方法区中，实例变量存放在堆内存中。
生命周期：类变量生存周期长，随着类的消失而消失，实例变量在对象消失后消失。

主函数main：是一个特殊的函数，作为程序的入口可以被jva调用。

主函数的定义：

public代表函数的访问权限是最大的。
static代表主函数在类加载的时候就已经存在。
void代表主函数没有具体的返回值。

静态代码块：
随着类的加载而执行，只执行一次。用于给类进行初始化。

class demo
{
    static
    {
        System.out.println(1);
    }
    demo()
    {
        System.out.println("i am demo");
    }
}
class day6
{
    static
    {
        System.out.println(2);
    }
    public static void main(String[] args)
    {
        demo k = new demo();
        System.out.println(3);
    }
    static
    {
        System.out.println(4);
    }
}

static代码块
先加载主类中的静态代码块，然后加载其他类中的静态代码块，此时，demo类中的静态代码块已经执行过一次，再次调用时，不会在执行静态代码，所以 i am demo只执行了一次。
静态代码块不能调用非静态变量

面向对象的对象初始化过程：
1.类加载。
2.静态代码块执行。
3.在堆内存中开辟内存。
在建立对象时的语句 demo case=new demo，做了什么？

new够用到了demo.class 所以会先找到demo.class文件并加载到内存中。
执行该类中的静态代码块，如果有，先给demo.class类进行初始化。
在堆内存中开辟空间，分配内存地址。
在堆内尺寸中建立的对象进行默认初始化。
对对象的属性进行初始化。
都对象进行构造代码块初始化。
对对象进行构造函数初始化。
将对象在内存中的地址给栈内存中的case。
代码中，构造代码块，静态代码块，调用函数的优先级

import org.omg.Messaging.SYNC_WITH_TRANSPORT;

class demo
{
    {
        System.out.println("who is advanced");
    }
    static
    {
        System.out.println(1);
    }
    demo()
    {
        System.out.println("i am demo");
    }
    public static  void show()
    {
        System.out.println("i am run demo");
    }
}
class day6
{
    static
    {
        System.out.println(2);
    }
    public static void main(String[] args)
    {
        demo k = new demo();
        System.out.println(3);
        k.show();
    }
    static
    {
        System.out.println(4);
    }
}

这片代码中，有两个类，类中有静态代码块和构造代码块。运行结果为

编译运行后，含有main函数的主类加载，该类中有两个静态代码块，先执行这两个静态代码块中的语句，所以先打印2，4，然后执行main函数中的语句，自上而下，先调用到demo类，demo类中有一块构造代码块和一块静态代码块，静态代码块先执行，先打印1，然后打印who is advanced? 再打印构造函数demo（）中的语句 i am demo,最后，k调用demo中的show函数打印语句 i am run demo。

对象调用成员的过程：
成员被加载到方法区，当对象调用成员时，栈中开辟一块空间，将方法调用，方法中的this有了对象的地址，传入参数进行运算，赋值，运算结束，栈中的内存被释放，这样，对象就调用了方法。
设计模式

Day 7

面向对象-继承
不同类中有相同的描述信息，将这些相同的信息提取出来，成为一个新类，所抽取的信息形成的类，称为父类，被抽取信息的类被称为子类。
extends关键字：关键字，继承。

class dad
{
    void out()
    {
        System.out.println("i am extends!");
    }
}
class son1 extends dad
{

}
class son2 extends dad
{

}
class day7
{
    public static void main(String[] args)
    {
        System.out.println("i am yours");
        son1 s1=new son1();
        son2 s2=new son2();
        s1.out();
        s2.out();
    }
}

extends

Java中不支持多继承，因为会造成安全隐患，而支持多层继承。
继承体系中，要使用这个体系的功能，先查看父类的功能，使用这个体系的功能时，要创建最子类的对象使用。因为可以能父类不能创建对象，而且最子类，具有的功能是包含父类与子类的所有功能。

class dad
{
    void out()
    {
        System.out.println("i am extends!");
    }
}
class son1 extends dad
{
    void out2()
    {
        System.out.println("i am extends2!");
    }
}
class son2 extends son1
{

}
class day7
{
    public static void main(String[] args)
    {
        System.out.println("i am yours");
        son2 s=new son2();
        s.out();
        s.out2();
    }
}

多层继承

聚集关系
聚合与组合：成员间的紧密程度不同，组合的紧密程度要高与聚合。
super关键字：super关键字，当子类出现非私有的同名变量时，子类如果想访问父类中的变量用super，访问本类中的成员用this，this与super的使用方法基本一致。
调用继承体系时，使用到子类时，现在方法区中的非静态区加载父类，再加载子类。
子父类中的函数覆盖（重写）
如果子类和父类中具有相同名称的函数，建立子类的对象后调用这个重名的函数，只会运行子类中的该名函数，父类中的该名函数被加载，但未被调用。当父类的功能不再能使用但没有必要直接删除的时候，可以使用函数覆盖功能，在子类中重写一个相同名称的函数。
注意：子类覆盖父类，必须保证子类的权限大于等于父类的权限才能够覆盖，否则，编译器会报错，静态不能覆盖非静态。

class dad
{
    int num=4;
        void out()
        {
        System.out.println("i am extends dad!");
        }
}
class son2 extends dad
{
    void out()
    {
        System.out.println("i am extends son!");
    }
}
class day7
{
    public static void main(String[] args)
    {
        System.out.println("i am yours");
        son2 s=new son2();
        s.out();
    }
}

重名函数的重写
子类父类中的构造函数：当子类与父类中都有构造函数时，对子类建立对象，调用对象时，会默认访问父类中的空参数构造函数，父类的构造函数优先于子类的构造函数运行，如果父类中的构造函数不是空参数构造函数，会报错。
子类的所有构造函数，都会默认访问父类中的空参数构造函数，因为子类中的每一个构造函数内都有一句隐式super（）。当父类中没有空参数的构造函数时，必须在子类中手动通过super语句类指定要访问的父类构造函数。
final关键字：final关键字时一个修饰符，可以修饰类，方法，变量，避免被重写。若被类final修饰，则无法被继承，未被final修饰的类可以被继承，指定final继承的方法无法被继承，被final修饰的变量只能被赋值一次。 final修饰的变量类似C语言中的define全局定义。final既可以修饰全局变量，也可以修饰成员变量。
抽象类：****abstract关键字当多个类中出现相同功能但是功能的主题不同的时候，还是可以进行抽取，但只是抽取功能定义而不是抽取功能的主体。
抽象的方法只能储存在抽象类中，abstract关键字修饰方法或类。抽象类不可以用new创建对象，因为调用抽象方法没有意义。抽象类的方法只能由子类建立对象调用使用。
抽象类中可以储存抽象方法和非抽象方法。

abstract class dad
{
   abstract void out();
}
class son1 extends dad
{
    void out()
    {
        System.out.println("i am extends son!");
    }
}
class son2 extends dad
{
    void out()
    {
        System.out.println("i am extends son2!");
    }
}
class day7
{
    public static void main(String[] args)
    {
        son1 s1=new son1();
        s1.out();
        son2 s2=new son2();
        s2.out();
    }
}

抽象方法

版式方法模式
**接口：**如果抽象类中的所有方法都是抽象的，那么这个类就可以成为接口。
关键字interface定义一个接口，接口中的常量定义格式时public static final ，方法的定义格式时public abstract
接口中的成员都是public的
类与类之间时继承关系，而类与接口之间是实现关系。接口无法创建对象。
关键字implements实现，描述类与接口之间的关系。
接口与接口之间可以有继承关系。

slny

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java Day5-7

Day 5构造函数：在类中中建立一个与类的相同名字的函数，该函数在对象一被调用的时候立即运行。在没有构造函数的对象中，系统会默认给该类加入一个空参数的构造函数。构造函数和一般函数的不同：构造函数在对象建立后就立即执行，一般函数需要调用，构造函数仅执行一次，一般函数可以多次调用。class demo{ demo () { System.out.println...
复制链接

扫一扫