即墨建网站价格,内容网站设计范例,中文网站建设合同,搜索引擎优化主要包括一、前言
Java是一种广泛应用于各个领域的编程语言#xff0c;它的面向对象编程范式使得它成为了当今软件开发的主要选择之一。通过面向对象编程#xff0c;Java使程序员能够将代码组织成易于理解和维护的结构#xff0c;并且在开发大型复杂的应用程序时提供了许多便利。
…一、前言
Java是一种广泛应用于各个领域的编程语言它的面向对象编程范式使得它成为了当今软件开发的主要选择之一。通过面向对象编程Java使程序员能够将代码组织成易于理解和维护的结构并且在开发大型复杂的应用程序时提供了许多便利。
与传统的过程式编程不同面向对象编程将程序组织成一系列相互独立的对象每个对象都有自己的属性和行为它们可以通过消息传递来与其他对象交互。这种编程范式使得代码更易于重用、扩展和测试并且有助于提高代码的可维护性和可读性。 1、什么是面向过程
C语言就算一门面向过程的语言面向过程编程Procedural Programming是一种计算机编程方法其核心思想是将程序视为一系列的过程或函数每个过程或函数都是完成一个特定的任务。面向过程编程强调步骤与逻辑的过程管理需要手动编写代码实现每一步骤。在面向过程编程中数据和方法是分离的通常使用全局变量进行数据传递。因此面向过程编程通常被认为是较低级别的编程方式其主要用途是解决简单或特定的问题。
2、什么是面向对象
Java是一门纯面向对象的语言(Object Oriented Program简称OOP)在面向对象的世界里一切皆为对象。面向对象是解决问题的一种思想主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序更符合人们对事物的认知对于大型程序的设计、扩展以及维护都非常友好。
3、两者的区别
以洗衣服为例
面向过程编程就像手洗衣服一样。你需要了解每个步骤例如湿润衣服、涂上洗涤剂、用刷子刷洗、用水冲洗、拧干等等。你需要自己决定每个步骤并进行大量的手动操作。而面向对象编程就像使用洗衣机一样。你只需要将脏衣服放进洗衣机按下按钮然后洗衣机会自动完成一系列步骤包括添加水、调节温度、旋转等操作。你不必关心每个步骤只需要掌握使用洗衣机的方法就能完成整个洗衣服的过程。
**在面向过程编程中我们需要手动实现每个步骤而在面向对象编程中我们只需要使用已经编写好的对象来完成任务。**这就是两者的区别。
在面向对象编程中对象是一个封装了方法和属性的实体我们可以通过使用这些对象来完成一系列的操作无需手动实现每个步骤这也减轻了开发工作的繁琐程度。但是要注意面向过程和面相对象并不是一门语言而是解决问题的方法没有那个好坏之分都有其专门的应用场景。 三、类
1、类的定义
在面向对象编程中**类Class是一种定义对象的模板。**类描述了一个对象具有的属性和方法它是创建对象的基础所有具有相同属性和方法的对象都属于同一个类。类通常包含数据成员属性和函数成员方法。属性是类中的变量描述了对象的基本信息而方法是类中的函数用于实现对象的各种行为。
举个简单例子假设我们要创建一个汽车类那么我们可以定义该类的属性包括汽车的品牌、型号、颜色等等方法包括发动、刹车、加速等等。当我们使用该类创建一个具体的对象时这个对象就会具有该类描述的所有属性和方法。
在Java中定义类时需要用到class关键字具体语法如下
// 创建类
class ClassName{field; // 字段(属性) 或者 成员变量定义在类中但是在方法的外面method; // 行为 或者 成员方法
}class是Java语言中用于定义类的关键字ClassName是要定义的类的名称命名规则和Java语言的标识符命名规则相同采用大驼峰命名法{}中是类的主体包含了类的所有属性和方法。类中包含的内容称为类的成员。属性主要是用来描述类的称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能称为类的成员方法。 2、举点例子
Ⅰ、定义一个汽车类
public class Car {//定义汽车属性private String brand; //品牌private String model; //型号private String color; //颜色private double speed; //车速private double fuel; //燃油量//定义汽车方法public void start() {System.out.println(汽车启动);}public void brake() {System.out.println(汽车刹车);}public void accelerate() {System.out.println(汽车加速);}public void decelerate() {System.out.println(汽车减速);}
}Ⅱ、定义一个学生类 public class Student{public String name;public String gender;public short age;public double score;public void DoClass(){}public void DoHomework(){}public void Exam(){}
}注意事项 一般一个文件当中只定义一个类 main方法所在的类一般要使用public修饰(注意Eclipse默认会在public修饰的类中找main方法) public修饰的类必须要和文件名相同
3、类的实例化
类的实例化是指根据一个类创建一个具体的对象这个对象就是该类的一个实例。在面向对象编程中类是一种抽象的概念而对象则是具体的实体。通过类的实例化我们可以创建多个不同的对象每个对象都有自己独立的属性和方法。
在Java中我们通过使用new关键字来创建一个类的实例例如
Car myCar new Car();上面的代码就创建了一个Car类的实例并将其赋给一个变量myCar。通过该变量我们可以访问这个具体的Car对象的属性和方法这个myCar变量是一个引用变量它包含了指向实际Car对象的内存地址。 在Java中对象是存储在堆内存中的而变量是存储在栈内存中的。当使用new关键字创建一个对象时Java会在堆内存中分配一块新的内存空间并返回该对象的引用。这个引用可以被存储在一个变量中以便在程序中引用该对象。 上面的这段Java代码其实就是创建了一个名为myCar的引用变量并使用new关键字在堆内存中创建了一个新的Car对象然后将该对象的引用赋值给了myCar变量。 注意事项 new 关键字用于创建一个对象的实例 使用 . 来访问对象中的属性和方法 同一个类可以创建对个实例
4、类和对象的说明
类只是一个模型一样的东西用来对一个实体进行描述限定了类有哪些成员。
类是一种自定义的类型可以用来定义变量。一个类可以实例化出多个对象实例化出的对象 占用实际的物理空间存储类成员变量。
类定义了对象的结构和行为而对象是类的一个具体实例具有自己独立的属性和方法。
做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子类就像是设计图只设计出需要什么东西但是并没有实体的建筑存在同样类也只是一个设计实例化出的对象才能实际存储数据占用物理空间。 5、类设计技巧 一定要保证数据私有 一定要对数据初始化 Java不对局部变量进行初始化但会对对象的实力域进行初始化。最好不依赖系统的默认值。 不要在类中使用过多的基本类型 用其他的类代替多个相关的基本类型的使用。这样会让类更加易于理解且易于修改。 不是所有的域都需要独立的域访问器或者域更改器将职责过多的类进行分解类名和方法名要体现它们的职责优先使用不可变的类
四、this引用
1、为什么要有this引用
public class Date {public int year;public int month;public int day;public void setDay(int y, int m, int d){year y;month m;day d;}public void printDate(){System.out.println(year / month / day);}public static void main(String[] args) {// 构造三个日期类型的对象 d1 d2 d3Date d1 new Date();Date d2 new Date();Date d3 new Date();// 对d1d2d3的日期设置d1.setDay(2020,9,15);d2.setDay(2020,9,16);d3.setDay(2020,9,17);// 打印日期中的内容d1.printDate();d2.printDate();d3.printDate();}}以上代码定义了一个日期类然后main方法中创建了三个对象并通过Date类中的成员方法对对象进行设置和打印代码整体逻辑非常简单没有任何问题。
但是细思之下有以下两个疑问
1、形参名不小心与成员变量名相同
public void setDay(int year, int month, int day){year year;month month;day day;
}那函数体中到底是谁给谁赋值成员变量给成员变量参数给参数参数给成员变量成员变量参数。
2、三个对象都在调用setDate和printDate函数但是这两个函数中没有任何有关对象的说明setDate和printDate函数如何知道打印的是那个对象的数据呢 2、什么是this引用
this引用指向当前对象(成员方法运行时调用该成员方法的对象)在成员方法中所有成员变量的操作都是通过该引用去访问。只不过所有的操作对用户是透明的即用户不需要来传递编译器自动完成。
this引用的作用就是区分成员变量和局部变量当一个方法的参数名和对象的成员变量名相同时使用this关键字可以指明是使用对象的成员变量还是方法的局部变量。
public class Date {public int year;public int month;public int day;public void setDay(int year, int month, int day){this.year year;this.month month;this.day day;}public void printDate(){System.out.println(this.year / this.month / this.day);}}注意this引用的是调用成员方法的对象。
public static void main(String[] args) {Date d new Date();d.setDay(2020,9,15);d.printDate();
}3、 this引用的特性
1、 this的类型对应类类型引用即哪个对象调用就是哪个对象的引用类型
2、this只能在成员方法中使用
3、在成员方法中this只能引用当前对象不能再引用其他对象
4、this是“成员方法”第一个隐藏的参数编译器会自动传递在成员方法执行时编译器会负责将调用成员方法对象的引用传递给该成员方法this负责来接收。
在代码层面来简单演示—注意下图右侧中的Date类也是可以通过编译的 五、对象构造及初始化
1、如何初始化对象
通过前面知识点的学习知道在Java方法内部定义一个局部变量时必须要初始化否则会编译失败。
比如
public static void main(String[] args) {int a;System.out.println(a);
}这段代码编译的时候就会出现Error:(26, 28) java: 可能尚未初始化变量a的报错提醒
要让上述代码通过编译非常简单只需在正式使用a之前给a设置一个初始值即可。
如果是对象
public static void main(String[] args) {Date d new Date();d.printDate();d.setDate(2021,6,9);d.printDate();
}需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。通过上述例子发现两个问题
1、每次对象创建好后调用SetDate方法设置具体日期比较麻烦那对象该如何初始化 为了避免这种问题我们可以在对象的构造方法中设置初始值这样对象一旦创建就会立即拥有完整的状态。在 Java 中我们可以使用构造方法来完成对象的初始化工作。 2、局部变量必须要初始化才能使用为什么字段声明之后没有给值依然可以使用 在Java中局部变量必须在使用之前先进行初始化否则编译器会报错。这是因为局部变量的生命周期只在其所在的方法内部而且局部变量的值是不可靠的如果没有初始化就使用它可能会导致程序出现异常。 而类成员变量字段则不同它们在类的实例化过程中被分配内存空间并赋予默认值因此即使没有给字段初始化也可以使用。具体来说Java会为不同类型的字段设置默认值 对于数值类型byte、short、int、long、float、double默认值为0或0.0。对于布尔类型boolean默认值为false。对于字符类型char默认值为null字符。对于引用类型类、接口、数组等默认值为null。 当然如果我们需要的话我们也可以在字段声明的时候给它们赋初值。这样做可以保证程序的健壮性避免不必要的错误。 2、什么是构造方法
构造方法是一种特殊的方法用于在创建对象时初始化对象的状态。构造方法的名字必须与类名相同它没有返回值也不能手动调用。在创建对象时Java 编译器会自动调用与对象类型相应的构造方法并执行其中的代码。
public class Date {public int year; // 成员变量年public int month; // 成员变量月public int day; // 成员变量日// 构造方法// 名字与类名相同没有返回值类型设置为void也不行// 一般情况下使用public修饰// 在创建对象时由编译器自动调用并且在对象的生命周期内只调用一次public Date(int year, int month, int day){this.year year; // 使用this关键字访问对象的成员变量并为其赋初值this.month month;this.day day;System.out.println(Date(int,int,int)方法被调用了); // 构造方法执行完毕输出消息}// 普通方法打印当前日期的字符串表示public void printDate(){System.out.println(year - month - day);}public static void main(String[] args) {// 此处创建了一个Date类型的对象并没有显式调用构造方法Date d new Date(2021,6,9); // 调用构造方法传入三个整数参数// 上述代码相当于调用了以下语句// Date d new Date(); // 创建一个空对象// d.year 2021; // 给成员变量赋值// d.month 6;// d.day 9;// 但是使用构造方法的方式更加简洁和安全可以保证对象的状态正确初始化d.printDate(); // 调用对象的方法输出对象的状态}
}为什么我没有写构造函数进行初始化我的代码也没有报错呢 在Java中如果你的构造方法一个都没写编译器则会为你自动生成一个默认的无参构造方法。这个默认构造方法会接受所有类型的参数并将它们设置为默认值(例如int类型的参数会被设置为0,布尔类型的参数会被设置为false等)。 3、构造方法的特性
名字必须与类名相同没有返回值类型设置为void也不行创建对象时由编译器自动调用并且在对象的生命周期内只调用一次(相当于人的出生每个人只能出生一次)构造方法可以重载(用户根据自己的需求提供不同参数的构造方法) 在Java中重载是指在同一个类中有多个方法具有相同的名称但参数列表不同的情况。每个构造方法必须具有唯一的参数列表因此当我们需要创建多个具有不同参数的构造方法时就需要进行重载。重载的构造方法可以使用不同的参数数量、类型和顺序从而在实例化对象时根据传递的参数来调用不同的构造方法。 public class Date {public int year; // 年份public int month; // 月份public int day; // 日期// 无参构造方法将日期初始化为1900年1月1日public Date(){this.year 1900;this.month 1;this.day 1;}// 带有三个参数的构造方法根据参数设置日期public Date(int year, int month, int day) {this.year year;this.month month;this.day day;}// 打印日期的方法public void printDate(){System.out.println(year - month - day);}public static void main(String[] args) {Date d new Date(); // 创建一个日期对象使用无参构造方法d.printDate(); // 调用打印日期的方法}
}上述两个构造方法名字相同参数列表不同因此构成了方法重载。
在构造方法中可以通过this调用其他构造方法来简化代码
public class Date {public int year;public int month;public int day;// 无参构造方法--内部给各个成员赋值初始值该部分功能与三个参数的构造方法重复// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法// 但是this(1900,1,1);必须是构造方法中第一条语句public Date(){//System.out.println(year); 注释取消掉编译会失败this(1900, 1, 1);//this.year 1900;//this.month 1;//this.day 1;}// 带有三个参数的构造方法public Date(int year, int month, int day) {this.year year;this.month month;this.day day;}
}注意 **this(…)**必须是构造方法中第一条语句 不能形成闭环 绝大多数情况下使用public来修饰特殊场景下会被private修饰(单例模式时会遇到) public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
}
/*
无参构造器调用三个参数的构造器而三个参数构造器有调用无参的构造器形成构造器的递归调用
编译报错Error:(19, 12) java: 递归构造器调用
*/每一个构造方法都需要我们自己写嘛 我们可以自己写也可以用idea生成构造方法。 这样我们就能生成一个构造函数了 4、默认初始化
局部变量必须要初始化才能使用为什么字段声明之后没有给值依然可以使用 在Java中局部变量必须在使用之前先进行初始化否则编译器会报错。这是因为局部变量的生命周期只在其所在的方法内部而且局部变量的值是不可靠的如果没有初始化就使用它可能会导致程序出现异常。 而类成员变量字段则不同它们在类的实例化过程中被分配内存空间并赋予默认值因此即使没有给字段初始化也可以使用。具体来说Java会为不同类型的字段设置默认值 对于数值类型byte、short、int、long、float、double默认值为0或0.0。对于布尔类型boolean默认值为false。对于字符类型char默认值为null字符‘\u0000’。对于引用类型类、接口、数组等默认值为null。 当然要想搞彻底清楚这个过程就需要知道 new 关键字背后所发生的一些事情
public class Date {public int year;public int month;public int day;public Date(int year, int month, int day) {// 成员变量在定义时并没有给初始值, 为什么就可以使用呢System.out.println(this.year);System.out.println(this.month);System.out.println(this.day);}public static void main(String[] args) {// 此处a没有初始化编译时报错// Error:(24, 28) java: 可能尚未初始化变量a// int a;// System.out.println(a);Date d new Date(2021,6,9);}
}在程序层面只是简单的一条语句在JVM层面需要做好多事情下面简单介绍下 检测对象对应的类是否加载了如果没有加载则加载 为对象分配内存空间 处理并发安全问题 初始化所分配的空间对象空间被申请好之后对象中包含的成员已经设置好了初始值 设置对象头信息 调用构造方法给对象中各个成员赋值 5、就地初始化
在声明成员变量时就直接给出了初始值。
public class Date {public int year 1900;public int month 1;public int day 1;public Date(){}public Date(int year, int month, int day) {}
public static void main(String[] args) {Date d1 new Date(2021,6,9);Date d2 new Date();}
}注意代码编译完成后编译器会将所有给成员初始化的这些语句添加到各个构造函数中
六、封装
1、封装的概念
面向对象程序三大特性封装、继承、多态。而类和对象阶段主要研究的就是封装特性。何为封装呢简单来说就是套壳屏蔽细节。
比如对于电脑这样一个复杂的设备提供给用户的就只是开关机、通过键盘输入显示器USB 插孔等让用户来和计算机进行交互完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。 对于计算机使用者而言不用关心内部核心部件比如主板上线路是如何布局的CPU内部是如何设计的等用户只需要知道怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时在外部套上壳子将内部实现细节隐藏起来仅仅对外提供开关机、鼠标以及键盘插孔等让用户可以与计算机进行交互即可。
封装将数据和操作数据的方法进行有机结合隐藏对象的属性和实现细节仅对外公开接口来和对象进行交互。 在Java中从语法层次上来看使用关键字private就可以做到。 被private修饰的属性只能在当前类中使用。 2、访问限定符
在Java中封装是通过访问控制符public、private、protected来实现的。通常情况下类的属性都应该使用private修饰符来限制外部访问而方法则可以使用public修饰符来允许外部访问从而实现对内部状态的保护和控制。 public多所有的类都可见
default: 对本包可见
private: 仅对本类可见
protected对本包和所有子类可见
【说明】 protected主要是在继承中使用 default权限指什么都不写时的默认权限 访问权限除了可以限定类中成员的可见性也可以控制类的可见性
public class Computer {private String cpu; // cpuprivate String memory; // 内存public String screen; // 屏幕String brand; // 品牌----default属性public Computer(String brand, String cpu, String memory, String screen) {this.brand brand;this.cpu cpu;this.memory memory;this.screen screen;}public void Boot(){System.out.println(开机~~~);}public void PowerOff(){System.out.println(关机~~~);}public void SurfInternet(){System.out.println(上网~~~);}}
public class TestComputer {public static void main(String[] args) {Computer p new Computer(HW, i7, 8G, 13*14);System.out.println(p.brand); // default属性只能被本包中类访问System.out.println(p.screen); // public属性 可以任何其他类访问// System.out.println(p.cpu); // private属性只能在Computer类中访问不能被其他类访问}
}注意一般情况下成员变量设置为private成员方法设置为public。
3、封装拓展包
Ⅰ、包的概念
在面向对象体系中提出了一个软件包的概念即为了更好的管理类把多个类收集在一起成为一组称为软件包。有点类似于目录。比如为了更好的管理电脑中的歌曲一种好的方式就是将相同属性的歌曲放在相同文件下也可以对某个文件夹下的音乐进行更详细的分类。 在Java中也引入了包包是对类、接口等的封装机制的体现是一种对类或者接口等的很好的组织方式。
比如一个包中的类不想被其他包中的类使用。
包还有一个重要的作用在同一个工程中允许存在相同名称的类只要处在不同的包中即可。
Ⅱ、导入包中的类
Java 中已经提供了很多现成的类供我们使用.
例如Date类可以使用 java.util.Date 导入 java.util 这个包中的 Date类
public class Test {public static void main(String[] args) {java.util.Date date new java.util.Date();// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}但是这种写法比较麻烦一些, 可以使用 import语句导入包
import java.util.Date;
public class Test {public static void main(String[] args) {Date date new Date();// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
import java.util.*; // .*相当于一个通配符可以充当任何类
public class Test {public static void main(String[] args) {Date date new Date();// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}但是更建议显式的指定要导入的类名否则还是容易出现冲突的情况
import java.util.*;
import java.sql.*;
public class Test {public static void main(String[] args) {// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错Date date new Date();System.out.println(date.getTime());}}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配在上面这种情况下则需要使用完整的类名
import java.util.*;
import java.sql.*;
public class Test {public static void main(String[] args) {java.util.Date date new java.util.Date();System.out.println(date.getTime());}
}可以使用import static导入包中静态的方法和字段。
import static java.lang.Math.*;
public class Test {public static void main(String[] args) {double x 30;double y 40;// 静态导入的方式写起来更方便一些.// double result Math.sqrt(Math.pow(x, 2) Math.pow(y, 2));double result sqrt(pow(x, 2) pow(y, 2));System.out.println(result);}
}注意事项: import 和 C 的 #include 差别很大, C 必须 #include 来引入其他文件内容, 但是 Java 不需要 import 只是为了写代码的时候更方便, import 更类似于 C 的 namespace 和 using
Ⅲ、常见的包 java.lang系统常用基础类(String、Object),此包从JDK1.1后自动导入。 java.lang.reflflectjava 反射编程包; java.net进行网络编程开发包。 java.sql进行数据库开发的支持包。 java.util是java提供的工具程序包。(集合类等) 非常重要 java.ioI/O编程开发包。
七、static成员
使用前文中介绍的学生类实例化三个对象s1、s2、s3每个对象都有自己特有的名字、性别年龄学分绩点等成员信息这些信息就是对不同学生来进行描述的如下所示
public class Student{
// ...public static void main(String[] args) {Student s1 new Student(Li leilei, 男, 18, 3.8);Student s2 new Student(Han MeiMei, 女, 19, 4.0);Student s3 new Student(Jim, 男, 18, 2.6);}
}假设三个同学是同一个班的那么他们上课肯定是在同一个教室那既然在同一个教室那能否给类中再加一个成员变量来保存同学上课时的教室呢
答案是不行的之前在Student类中定义的成员变量每个对象中都会包含一份**(**称之为实例变量)因为需要使用这些信息来描述具体的学生。 而现在要表示学生上课的教室这个教室的属性并不需要每个学生对象中都存储一份而是需要让所有的学生来共享。
在Java中被static修饰的成员称之为静态成员也可以称为类成员其不属于某个具体的对象是所有对象所共享的。
1、static修饰成员变量
static修饰的成员变量称为静态成员变量静态成员变量最大的特性不属于某个具体的对象是所有对象所共享的 。 普通成员变量在类的内部方法的外部 静态成员变量在类的内部方法的外部被static修饰了 局部变量方法内部定义的变量 【静态成员变量特性】
静态成员不属于某个具体的对象是类的属性所有对象共享的不存储在某个对象的空间中既可以通过对象访问也可以通过类名访问但一般更推荐使用类名访问类变量存储在方法区当中生命周期伴随类的一生(即随类的加载而创建随类的卸载而销毁)
【静态成员的访问方式】
不建议通过对象的引用访问建议通过类名.的方式进行访问
public class Student{public String name; //普通成员变量public String gender; //普通成员变量public int age; //普通成员变量public double score; //普通成员变量public static String classRoom 401; //静态成员变量// ...
public static void main(String[] args) {// 静态成员变量可以直接通过类名访问说明静态成员变量并不属于对象System.out.println(Student.classRoom);Student s1 new Student(Li leilei, 男, 18, 3.8);Student s2 new Student(Han MeiMei, 女, 19, 4.0);Student s3 new Student(Jim, 男, 18, 2.6);// 也可以通过对象访问但是classRoom是三个对象共享的但是不建议这样去写。System.out.println(s1.classRoom);System.out.println(s2.classRoom);System.out.println(s3.classRoom);}
}2、static修饰成员方法
在Java中static关键字也可以用来修饰方法使得这些方法与类本身关联而不是与类的具体对象关联。
这意味着你可以在不创建类的对象的情况下调用这些方法。以下是static修饰成员方法的一些关键点 不需要创建对象static方法不需要创建类的对象就可以调用。你可以直接使用类名来调用它们如MyClass.staticMethod()。 只能访问静态成员static方法不能直接访问类中的非静态成员变量和方法。它们只能访问静态成员。 常用于工具类static方法通常用于实现那些与类的状态无关的功能例如工具类和帮助方法。
下面是一个简单的例子来说明static修饰成员方法的使用
public class Student {// ... 其他成员变量和方法 ...// 使用 static 关键字修饰一个名为 classRoom 的成员变量并赋值为 301private static String classRoom 301;// ... 其他成员变量和方法 ...// 定义一个名为 getClassRoom 的 static 方法用于获取 classRoom 变量的值public static String getClassRoom() {return classRoom;}
}
public class TestStudent {public static void main(String[] args) {// 直接通过Student类名调用 getClassRoom 方法System.out.println(Student.getClassRoom());}
}
我们直接使用类名Student调用getClassRoom()方法而不需要创建类的对象。
【静态方法特性】 不属于某个具体的对象是类方法 可以通过对象调用也可以通过类名.静态方法名(...)方式调用更推荐使用后者 不能在静态方法中访问任何非静态成员变量 public static String getClassRoom(){System.out.println(this);return classRoom;}// 编译失败Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 thispublic static String getClassRoom(){age 1;return classRoom;}// 编译失败Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age静态方法中不能调用任何非静态方法因为非静态方法有this参数在静态方法中调用时候无法传递this引用
public static String getClassRoom(){doClass();return classRoom;
}
// 编译报错Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()值得注意的是main方法也是一种静态方法。main方法不对任何对象进行操作。事实上在启动程序时还没有任何一个对象。
静态的main方法将执行并创建程序所需要的对象。
3、static成员变量初始化
注意静态成员变量一般不会放在构造方法中来初始化构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种就地初始化 和 静态代码块初始化。
就地初始化在定义时直接给出初始值
public class Student{private String name;private String gender;private int age;private double score;private static String classRoom 301; // ...
}静态代码块初始化静态代码块是一种特殊的代码结构用于在类加载时初始化静态成员变量。它在类中使用static关键字定义并由一对大括号{}包围。静态代码块在类加载时自动执行且仅执行一次。
八、代码块
1、普通代码块
普通代码块定义在方法中的代码块。这种用法较少见
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 1002、构造代码块
构造代码块定义在类中的代码块(不加修饰符)。也叫实例代码块。
构造代码块一般用于初始化实例成员变量。
public class Student{//实例成员变量private String name;private String gender;private int age;private double score;public Student() {System.out.println(I am Student init()!);
}
//实例代码块
{this.name 123;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) {Student stu new Student();stu.show();}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man3、静态代码块
使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量
public class Student {// 声明一些实例变量private String name;private String gender;private int age;private double score;// 声明一个静态变量private static String classRoom;// 实例代码块用于初始化实例变量{this.name bit;this.age 12;this.gender man;System.out.println(I am instance init()!);}// 静态代码块用于初始化静态变量static {classRoom bit306;System.out.println(I am static init()!);}// 构造函数用于创建 Student 类的对象public Student() {System.out.println(I am Student init()!);}public static void main(String[] args) {// 创建两个 Student 类的对象Student s1 new Student();Student s2 new Student();}
}注意事项
静态代码块不管生成多少个对象其只会执行一次静态成员变量是类的属性因此是在JVM加载类时开辟空间并初始化的如果一个类中包含多个静态代码块在编译代码时编译器会按照定义的先后次序依次执行(合并)实例代码块只有在创建对象时才会执行
4、执行顺序
在Java中代码块、构造函数和静态代码块的执行顺序如下 静态代码块在类加载时执行且仅执行一次。静态代码块优先于其他成员的初始化执行即使没有创建实例也会执行静态代码块。 实例代码块每次创建实例时都会执行。在实例化之前实例代码块会在构造函数之前执行。 构造函数构造函数会在实例代码块执行完毕后执行。
示例代码
public class Example {static {System.out.println(执行静态代码块);}{System.out.println(执行实例代码块);}public Example() {System.out.println(执行构造函数);}public static void main(String[] args) {new Example();new Example();}
}输出结果
执行静态代码块
执行实例代码块
执行构造函数
执行实例代码块
执行构造函数从输出结果可以看出静态代码块在类加载时只会执行一次实例代码块和构造函数在每次创建实例时都会执行。
九、对象的打印
在Java中如果你想打印一个对象的信息可以使用System.out.println()方法并将对象传递给它。当你这样做时Java将自动调用对象的toString()方法将其转换为一个字符串并打印出来。 在Java中每个对象都有一个默认的toString()方法它返回一个包含类名和对象的内存地址的字符串。 // 定义一个名为 Person 的类
public class Person {// 声明一些实例变量String name;String gender;int age;// 构造函数用于创建 Person 类的对象public Person(String name, String gender, int age) {this.name name;this.gender gender;this.age age;}// 主函数public static void main(String[] args) {// 创建一个 Person 类的对象Person person new Person(Jim, 男, 18);// 打印该对象Java将自动调用对象的 toString() 方法System.out.println(person);}
}
// 打印结果day20210829.Person1b6d3586 如果想要默认打印对象中的属性该如何处理呢
答案重写toString方法并在其中返回你想要的字符串。
// 定义一个名为 Person 的类
public class Person {// 声明一些实例变量String name;String gender;int age;// 构造函数用于创建 Person 类的对象public Person(String name, String gender, int age) {this.name name;this.gender gender;this.age age;}// 重写 toString() 方法返回一个包含对象属性的字符串Overridepublic String toString() {return [ name , gender , age ];}// 主函数public static void main(String[] args) {// 创建一个 Person 类的对象Person person new Person(Jim, 男, 18);// 打印该对象Java将自动调用对象的 toString() 方法System.out.println(person);}
}
// 输出结果[Jim,男,18]【总结】
如果我们没有覆盖toString()方法Java将使用默认的toString()方法生成一个字符串该字符串由类名、符号和对象的内存地址组成。
例如对于一个名为Person的类它的默认toString()方法生成的字符串可能是Person1b6d3586。
这并不是我们所期望的输出结果因为它没有显示对象的属性。
为了让对象的属性默认被打印出来我们可以覆盖toString()方法并在其中返回一个包含对象属性的字符串。例如假设我们有一个名为Person的类其中包含了一些实例变量name、gender和age那么我们可以在Person类中添加以下toString()方法来返回一个包含对象属性的字符串
Override
public String toString() {return [ name , gender , age ];
}当我们调用System.out.println()方法并将一个Person对象传递给它时Java将自动调用该对象的toString()方法并打印出返回的字符串。例如
Person person new Person(Jim, 男, 18);
System.out.println(person);输出结果将是[Jim,男,18]它显示了person对象的属性。
需要注意的是重写toString()方法是可选的它不影响对象本身的行为只是为了方便调试和输出。在编写代码时我们可以根据需要决定是否要覆盖toString()方法。
十、一些练习
1、下面代码的运行结果是
public static void main(String[] args){String s;System.out.println(ss);
}A.代码编程成功并输出”s”
B.代码编译成功并输出”snull”
C.由于String s没有初始化代码不能编译通过。
D.代码编译成功但捕获到Null Point Exception异常 答案C 本题中的代码不能编译通过因为在Java当中局部变量必须先初始化后使用。所以此处编译不能通过 2、阅读如下代码。 请问对语句行 test.hello()描述正确的有
package NowCoder;
class Test {public static void hello() {System.out.println(hello);}
}
public class MyApplication {public static void main(String[] args) {// TODO Auto-generated method stubTest testnull;test.hello();}
}A.能编译通过并正确运行
B.因为使用了未初始化的变量所以不能编译通过
C.以错误的方式访问了静态方法
D.能编译通过但因变量为null不能正常运行 答案A hello方法被static修饰是一个静态方法调用静态方法不需要创建实例对象。 此时的Test testnull; 表示test这个引用不指向任何对象。所以此处可以正常访问。 如果hello方法没有加static修饰那么这段代码必然会报错。 但是我们需要牢记静态方法的正确访问方式应该是用过类型来访问。即Test.hello(); 3、如下代码的输出结果是什么
public class Test { public int aMethod(){static int i 0;i; return i;}
public static void main(String args[]){Test test new Test(); test.aMethod(); int j test.aMethod();System.out.println(j);}
}A. 0
B. 1
C. 2
D.编译失败 答案D static int i 0;这段代码语句错了因为他是在方法当中定义的变量。 在方法当中定义的变量是局部变量而静态的变量属于类的变量。 静态变量随着类的加载而被创建而局部变量是调用该方法的时候才创建的。所以此时两种变量的性质是冲突的。Java当中不允许定义局部的静态变量。 4、当你编译和运行下面的代码时会出现下面选项中的哪种情况
public class Pvf{static boolean Paddy;public static void main(String args[]){System.out.println(Paddy);}
}A.编译时错误
B.编译通过并输出结果false
C.编译通过并输出结果true
D.编译通过并输出结果null 答案B 在Java当中成员变量没有赋初值的时候会有默认的初始值。基本类型是对应的0值。如int是0boolean是false,char类型是’\u0000’引用类型是null如String。 5、已知如下类说明
public class Test{private float f1.0f;int m12;static int n1;public static void main(String args[]){Test tnew Test();}
}如下哪些在main函数中使用是正确的
A. t.f 3.0
B. this.n
C. Test.m
D. Test.n 答案D Af是私有的private不能在类的外部直接访问。并且在Java中浮点数字面量默认被视为double所以3.0是double类型不能直接赋值给float类型变量f。应使用类型转换或者float类型字面量。 Bthis关键字用于引用当前实例。在静态方法如main方法中没有当前实例因为静态方法属于类本身而非特定实例。因此不能在静态方法中使用this关键字。 Cm是一个非静态成员变量不能通过类名直接访问。要访问非静态成员变量需要使用类的实例。 Dn是一个静态成员变量可以通过类名直接访问。在main方法中使用Test.n是正确的。所以这个选项是正确的。 6、关于以下程序代码的说明正确的是() public class HasStatic {// 1private static int x 100;// 2public static void main(String args[]) {// 3HasStatic hsl new HasStatic();// 4hsl.x;// 5HasStatic hs2 new HasStatic();// 6hs2.x;// 7hsl new HasStatic();// 8hsl.x;// 9HasStatic.x--;// 10System.out.println( x x);// 11}
}A. 程序通过编译输出结果为:x102
B. 程序通过编译输出结果为:x103
C. 10行不能通过编译.因为x星私有静态变量
D. 5行不能通过编译.因为引用了私有静态变量 答案A 本题中的静态成员变量x属于类变量只有一份。所有对x的操作针对的都是同一份。静态成员变量的访问需要通过类名访问这是正确的访问方式。本题中虽然使用了对象引用访问但是不会报错我们不建议这样访问但不是错误所以不会编译报错。 综合以上2点得出结论本题可以正常通过编译和运行输出结果是102。 7、以下代码在编译和运行过程中会出现什么情况
public class TestDemo{private int count;public static void main(String[] args) {TestDemo testnew TestDemo(88);System.out.println(test.count);}TestDemo(int a) {counta;}}A.编译运行通过输出结果是88
B.编译时错误count变量定义的是私有变量
C.编译时错误System.out.println方法被调用时test没有被初始化
D.编译和执行时没有输出结果 答案A TestDemo test new TestDemo(88);这段代码会先执行构造方法将88的值赋值给count所以最终输出的值是88 8、在JAVA中假设A有构造方法A(int a)则在类A的其他构造方法中调用该构造方法和语句格式应该为
A.this.A(x)
B.this(x)
C.super(x)
D. A(x) 答案B this共有2种使用方式 this.data 访问当前对象的实例成员变量 this.func() 访问当前对象的实例成员方法 this(参数列表) 访问当前对象的构造方法 此处在当前类当中调用构造方法A(int a)使用this(x);的方式所以选择B。 A不能通过点号访问构造方法 Csuper(x)是初始化父类继承过来的那部分成员 D缺少this
