Java类和对象

zero.

已于 2023-10-25 08:43:24 修改

阅读量2.3k

点赞数 4

文章标签：学习 java 开发语言

于 2023-04-02 09:30:48 首次发布

本文链接：https://blog.csdn.net/2302_76432836/article/details/129738707

版权


class Date{
    {
        System.out.println("我是普通代码块1");
    }
    {
        System.out.println("我是普通代码块2");
    }
}
public class Static {
    public static void main(String[] args) {
       Date date = new Date();
    }
}
//输出
我是普通代码块1
我是普通代码块2

可见当类内无构造方法时呕吐代码块是按顺序执行的，可若有构造方法呢？

接下来看看这串代码


class Date{

    public Date() {
        System.out.println("我是构造方法");
    }

    {
        System.out.println("我是普通代码块");
    }
}
public class Static {
    public static void main(String[] args) {
       Date date = new Date();
    }
}
//输出
我是普通代码块
我是构造方法

可见，普通代码块的执行是优先于构造方法的

1.5.2 构造代码块

其实也就是在构造方法后的代码块，可以用于初始化非静态成员变量（前提是不带参数的构造方法）

首先是无参数的构造方法


class Date{
    public int a;
    public Date() {

    }
    {
        System.out.println("构造代码块");
        a = 100;
    }
}
public class Static {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.a);
    }
}
//输出
//构造代码块
//100

可以看到，我们可以通过构造代码块给成员变量赋值

接下来看看有参数的构造方法会输出什么


class Date{
    public int a;
    public Date(int a) {
        System.out.println("无参数的构造方法");
        this.a = a;
    }

    {
        System.out.println("构造代码块");
        a = 100;
    }
}
public class Static {
    public static void main(String[] args) {
        Date date = new Date(200);
        System.out.println(date.a);
    }
}
//输出
构造代码块
无参数的构造方法
200

从这里可以发现构造代码块执行会优先于构造方法

1.5.3 静态代码块

其实也就是加上static的代码块，可用于初始化静态成员变量（此处有在1.4.3-(5)提到过），或者提前准备一些数据


class Date{
    public static int a;
    static{
        a = 520;
    }
}
public class Static {
    public static void main(String[] args) {
        System.out.println(Date.a);
    }
}
//输出
520

接下来，我们来看看静态代码块的执行是否也优先于构造方法呢？


class Date{

    public Date() {
        System.out.println("构造方法");
    }
    static{
        System.out.println("静态代码块1");
    }
    static{
        System.out.println("静态代码块2");
    }
}
public class Static {
    public static void main(String[] args) {
       Date date = new Date();
    }
}
//输出
静态代码块1
静态代码块2
构造方法

可见，静态代码块是按循序执行的，而构造方法是最后执行的

接下来，再来看一段代码


class Date{
    {
        System.out.println("普通代码块1");
    }
    static {
        System.out.println("静态代码块1");
    }
    static {
        System.out.println("静态代码块");
    }
}
public class Static {
    public static void main(String[] args) {
       Date date = new Date();
        System.out.println("----------------");
       Date date1 = new Date();
    }
}

//输出
静态代码块1
静态代码块
普通代码块1
-------------
普通代码块1

突然发现，第二次实例化对象时并没有输出静态代码块内的内容，这说明静态代码块只执行一次

1.5.4 代码块执行顺序

看完上述内容后，可以得到无论是什么代码块的执行都优先于构造方法

那么也许会有人疑惑，如果这些代码块类都组合在一起，会是哪一中代码块会先执行呢？

接下来我们看代码


class Date{
    public Date() {
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块1");
    }
    static {
        System.out.println("静态代码块1");
    }
    {
        System.out.println("普通代码块1");
    }
}
public class Static {
    public static void main(String[] args) {
       Date date = new Date();
        System.out.println("main方法");
    }
    static {
        System.out.println("静态代码块2");
    }
    {
        System.out.println("普通代码块2");
    }
}

//输出
静态代码块2
静态代码块1
构造代码块1
普通代码块1
构造方法
main方法

可见，静态代码块优先于所有种类的代码块，而public类内的静态代码块的执行优先于其他类的静态代码块，其次是构造代码块，再是普通代码块，然后再是构造方法，最后是main方法

即，静态代码块-> 构造代码块-> 普通代码块-> 构造方法-> main方法

那么这时就会有人问了：为什么普通代码块2没有执行呀？

继续看代码


class Date{

    {
        System.out.println("普通代码块1");
    }
    {
        Static sta = new Static();
    }
}
public class Static {
    public static void main(String[] args) {
       Date date = new Date();
        System.out.println("main方法");
        Static sta = new Static();
    }
    {
        System.out.println("普通代码块2");
    }
}

//输出
普通代码块1
普通代码块2
main方法
普通代码块2

可见，要在其他类或者是main方法内执行普通代码块都需要实例化对象

2. 继承 -- externds

此处简单叙述，作者无能还没有学的太深入

假设我们要定义一个狗类和猫类，那么狗和猫都一样的属性 -- 名字和年龄等，不妨把这些共性提出来，构建一个父类，让狗和猫这些子类都继承父类所有的属性。

继承：对共性进行抽取，从而实现代码的复用（需要用到关键字externds）

2.1 父类和子类

还是用上述动物的例子来写代码


class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name + "正在吃饭");
    }
}
class Dog extends Animal{     //dog继承父类Animal

    public void howl(){
        System.out.println(name + " 正在汪汪叫");
    }
}
class Cat extends Animal{

    public void howl(){
        System.out.println(name + " 正在喵喵叫");
    }
}
public class inherit {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        dog.eat();
        Cat cat = new Cat();
        System.out.println(cat.name);
    }
}
//输出
null
null正在吃饭
null

其中，Animal就是父类，而dog和cat就是子类

可以看到子类可以继承父类的成员变量和成员方法，输出null是因为我们还没有给成员变量赋值，所以系统提供默认值

2.2 继承中的构造方法 -- super

子类要实现构造方法时，必须先要帮父类实现构造方法

这是我们要用到关键字super -- 代表着父类的引用，可以和this类比


class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public Animal(String name, int age) {      //父类的构造方法
        this.name = name;
        this.age = age;
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);              //子类帮助父类实现构造
    }

    public void howl(){
        System.out.println(name + " 正在汪汪叫");
    }
}
public class inherit {
    public static void main(String[] args) {
        Dog dog = new Dog("修狗",3);
        System.out.println(dog.name);
        dog.eat();
    }
}
//输出
修狗
修狗正在吃饭

其中，super();必须要在子类构造方法的第一行，而且也只能在构造方法内使用，不然会报错

3. 权限

权限：访问修饰限定符，即修改方法或者是变量的访问范围

private, default ,protected ,public

3.1 封装 -- private

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

这就好比去银行取钱，不可能把你西汉卡的信息一下子全展现出来，需要保护你的信息，只提供你取钱的途径，所以封装提高了数据的安全性

(1) 构造方法实现封装对外的接口

利用构造方法的快捷方法


class Student{
    private String name;
    private int age;
    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println(this.name);
        System.out.println(this.age);
    }
}
public class Private {
    public static void main(String[] args) {
        Student student = new Student("zero",18);
        student.show();
    }
}

//输出
zero
18

如此，利用private关键字将name和age这两个成员变量封装起来，也就是改变着两个成员变量的权限，使得它们只能在类里面使用，然后利用构造方法提供对外的接口为成员变量赋值

如果在类外使用就会报错

很明显我们不可以通过引用来引用对象已经封装了的变量

(2) get和set方法实现封装对外的接口

使用get和set的快捷方法，让IDEA帮我们写代码


class Student{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Private {
    public static void main(String[] args) {
        Student student = new Student();
        student.setAge(18);
        student.setName("zero");
        System.out.println(student.getName());
        System.out.println(student.getAge());
    }
}
//输出
zero
18

3.2 包访问权限/默认权限 -- defoult

该权限不用写出来

3.2.1包

由于是包访问权限这里简单引入包的概念

包：实际上也就是文件夹，用来整理类

包的名字一般是域名，com.开头,www结尾

例如com.zero.www

创建包

然后输入包的名字，最后可以在包里面定义类

就可以再类里面打代码了

3.2.2 包访问权限一 . 在同一个中的同一类中访问


package com.zero.www;
//声明当前类是在哪一个包底下

public class Test {
    int a = 999;

    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.a);
    }
}
//输出
999

可以看到，这是在com.zero.www包下的Test类下

default不用写出来，但是a在Test类下可以使用

3.2.3 包访问权限二 . 在同一个包中的不同类访问

接下来我再创建另外一个类 Test1 类，再来访问a


package com.zero.www;
//声明当前类是在哪一个包底下

class Test1{
    public Test1() {
        Test test = new Test();
        System.out.println(test.a);
    }
}
public class Test {
    int a = 999;
    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.a);
        Test1 test1 = new Test1();
    }
}
//输出
999
999

可见，在同一个包中的不同类也能访问a变量

3.3 protected（保护）访问权限

protected有着default有的两个权限

3.3.1 权限一在同一个中的同一类中访问

首先按上述操作创建一个包demo1，再在包内创建一个类Test1

输入以下代码


package demo1;

public class Test1 {

    protected static int a = 999;
    public static void main(String[] args) {
        System.out.println(a);

    }
}
//输出
999

加上static只是了方便引用，可以直接用类名引用

可见，a可以在同一个demo1当中的同一个test1类中使用

3.3.2 权限二在同一个包中的不同类中使用

同样是在demo1包中，定义一个Test2类，在该类中使用a


package demo1;

public class Test2 {

    public static void main(String[] args) {
        System.out.println(Test1.a);
    }
}
//输出
999

可见，a在同一个demo1包中的Test2类也可以使用

3.3.3 权限三在不同包中的子类中使用

此处就要用到上述继承的知识啦

创建另一个包demo2 ，在该包中创建一个类Test3，另Test3继承Test1


package demo2;

import demo1.Test1;

public class Test3 extends Test1 {
    public static void main(String[] args) {
        System.out.println(Test1.a);
    }
}
//输出
999

可见，demo1中Test1类中的a也可以在demo2中继承了Test1的Test3中使用