Java中的类和对象
文章目录
- 一、类和对象的基本概念
- 二、类和对象的定义和使用
-
- 1.创建类的语法
- 2.创建类的对象
- 3.范例(创建一个类的对象)
- 三、this引用
-
- 1.什么是this引用
- 2.this引用的特性
- 四、构造方法
-
- 1.构造方法的概念
- 2.构造方法的特性
- 五、封装
-
- 1.封装的概念
- 2.访问限定符
- 3.封装扩展包
-
- 3.1包的概念
- 3.2常见的包
- 六、static成员
-
- 1.static修饰成员变量
- 2.static修饰成员方法
- 3.static成员变量初始化
- 七、代码块
-
- 1.代码块的概念及分类
- 2.普通代码块
- 3.构造代码快
- 4.静态代码块
- 八、对象的打印
一、类和对象的基本概念
类和对象是整个面向对象中最基本的组成单元
类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。
可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的
二、类和对象的定义和使用
1.创建类的语法
在java中定义类时需要用到class关键字，语法如下：
class 类名称 {
成员变量/ 实例变量；
成员方法；
}
2.创建类的对象
格式一:声明并实例化对象
类名称 对象名称 = new 类名称 () ;
格式二：先声明对象，然后实例化对象
类名称 对象名称 = null ;
对象名称 = new 类名称 () ;
引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间
当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性；
对象.方法()：表示调用类之中的方法
3.范例(创建一个类的对象)
class Person {
//成员变量（实例变量），在堆中的每个对象中存储，通过对象调用
String name;//默认值为null
int age;//默认值为0
String sex;//默认值为null
//成员方法（实例方法），在JVM的方法区中存储，通过对象调用
public void get() {
System.out.println("姓名:" + name + " 年龄:" + age + " 性别:"+ sex);
}
}
public class Test {
public static void main(String[] args) {
//创建一个实例化对象
Person per = new Person();
//通过对象来调用成员变量和方法
per.name = "小郑";
per.age = 20;
per.sex = "男";
per.get();
}
}
注意：
1.在Java中一个源文件（*.java）只可以存在一个主类（public class）
2.类的命名规则：使用有意义的大驼峰单词命名法，每个单词的首字母都要大写
3.类中定义的成员变量都有默认值
4.关于引用数据类型的特殊值 null:null在Java中表示“空引用”，即只有名字，没有任何对内存中的地址，如果直接使用值为null的引用，去操作（使用.操作符）任何属性或者方法（成员变量、成员方法），都会报错。 如：空指针异常
三、this引用
class Data {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}
public void printDate(){
System.out.println(year + "/" + month + "/" + day);
}
}
public class Test1 {
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Data d1 = new Data();
Data d2 = new Data();
Data d3 = new Data();
// 对d1，d2，d3的日期设置
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函数如何知道打印的是那个对象的数据呢
1.什么是this引用
this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问
class Data {
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(year + "/" + month + "/" + day);
}
}
注意：this引用的是调用成员方法的对象
public static void main(String[] args) {
Data d = new Data();
d.setDay(2020,9,15);
d.printDate();
}
2.this引用的特性
- this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
- this只能在"成员方法"中使用
- 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
- this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收
四、构造方法
1.构造方法的概念
构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次
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.month = month;
this.day = day;
System.out.println("Date(int,int,int)方法被调用了");
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
}
public class Test {
public static void main(String[] args) {
// 此处创建了一个Date类型的对象，并没有显式调用构造方法
Date d = new Date(1949,10,1); // 输出Date(int,int,int)方法被调用了
d.printDate();
}
}
注意: 构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间
2.构造方法的特性
1、构造方法：构造方法是类中非常特殊的一类方法，使用关键字new 实例化对象时实际上调用的就是该类的构造方法。
2.构造方法的作用就是产生对象
3.使用new关键字产生一个对象时，大致分为以下两步：
（1）为对象在堆中分配空间（空间大小由该类中成员变量的属性决定）
（2）调用对象的构造方法为对象成员变量赋值（当构造方法调用结束后，该对象初始化完成）
4.构造方法的语法规则
（1）方法名称与类名称完全相同
（2）构造方法没有返回值声明（不是void）
（3）一个类中至少存在一个构造方法，若没有显示定义，编译器会生成一个默认的无参构造
class Person {
String name;
int age;
String sex;
//构造方法和类的名称完全相同
//没有返回值声明
public Person(){
System.out.println("无参数的构造方法");
}
}
public class Data {
public static void main(String[] args) {
//创建一个对象默认调用该类的构造方法
Person per = new Person();
}
}
如果没有定义构造方法，编译器会默认生成一个无参数的构造方法
class Person {
String name;
int age;
String sex;
}
public class Data {
public static void main(String[] args) {
//创建一个对象默认调用该类的构造方法
Person per = new Person();
}
}
5.当类中自定义了构造方法，默认的无参构造就不再生成
class Person{
String name;
int age;
String sex;
public Person(String n){
name = n ;
System.out.println("Person类的有参构造");
}
}
public class Data {
public static void main(String[] args) {
//创建一个对象默认调用该类的构造方法
Person per = new Person();
}
}
6.构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)和在构造方法中，可以通过this调用其他构造方法来简化代码
class Data{
int year;
int month;
int day;
public Data(){//不带参数的构造方法
//this.year = 1949;
//this.month = 10;
//this.day = 1;
this(1949,10,1);
}
public Data(int year){
this.year = year;
System.out.println("带一个参数的构造方法");
}
public Data(int month, int day) {
this.month = month;
this.day = day;
System.out.println("带两个参数的构造方法");
}
public Data(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
System.out.println("带三个参数的构造方法");
}
public void printData(){
System.out.println(year+"-"+month+"-"+day);
}
}
public class Test2 {
public static void main(String[] args) {
Data data = new Data();
data.printData();
}
}
上述几个构造方法：名字相同，参数列表不同，因此构成了方法重载
注意：
this(…)必须是构造方法中第一条语句
不能形成环
五、封装
1.封装的概念
面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互
2.访问限定符
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用
private（私有的）：被private 修饰的属性和方法，只在当前类可见，出了类的{ }，对外就完全隐藏了，外部不知道有其存在。
default(不需要写这个关键字，什么权限也没有（包访问权限）)
protected（继承访问权限）
public（公共的、公开的）：被public 修饰的，在当前程序（项目）中都是可见并且可以使用的
3.封装扩展包
3.1包的概念
在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包
在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可
3.2常见的包
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
- java.lang.reflect:java 反射编程包;
- java.net:进行网络编程开发包。
- java.sql:进行数据库开发的支持包。
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包
六、static成员
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的
1.static修饰成员变量
static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
【静态成员变量特性】
1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3.类变量存储在方法区当中
4.生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
class Student {
public String name;
public String gender;
public int age;
public double score;
public Student(String name, String gender, int age, double score) {
this.name = name;
this.gender = gender;
this.age = age;
this.score = score;
System.out.println("name:"+name+" gender:"+gender+" age:"+age+" score:"+score);
}
// 静态成员变量可以直接通过类名访问
public static String classRoom = "Lzy306";
}
public class Test1 {
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修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的
【静态方法特性】
1.不属于某个具体的对象，是类方法
2.可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
3.不能在静态方法中访问任何非静态成员变量
4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
3.static成员变量初始化
注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化和静态代码块初始化
1.就地初始化
就地初始化指的是：在定义时直接给出初始值
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306";
}
2.静态代码块初始化
这个我们在代码块中讲解
七、代码块
1.代码块的概念及分类
使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块（后续讲解多线程部分再谈）
2.普通代码块
public class Data {
public static void main(String[] args) {
{
int i = 10;
System.out.println("i="+i);
}
{
int m = 20;
System.out.println("m="+m);
}
}
}
3.构造代码快
构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量
class Student{
//实例成员变量
private String name;
private String sex;
private int age;
public Student(){
System.out.println("I am student");
}
//实例代码块
{
this.name = "小郑";
this.sex = "男";
this.age = 18;
System.out.println("my student");
}
public void shou() {
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student();
student.shou();
}
}
4.静态代码块
使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量
class Student {
private String name;
private String sex;
private int age;
private static String classroom;
//实例代码块
{
this.name = "小郑";
this .sex = "男";
this.age = 20;
System.out.println("I am student");
}
//静态代码块
static {
Student.classroom = "lzy502";
System.out.println("you student");
}
public Student(){
System.out.println("is student");
}
}
public class Dome {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student();
}
}
注意：
1.静态代码块不管生成多少个对象，其只会执行一次
2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
4.实例代码块只有在创建对象时才会执行
八、对象的打印
class Student {
String name;
String sex;
int age;
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
public class Data {
public static void main(String[] args) {
Student student = new Student("小郑","男", 20);
System.out.println(student);
}
}
如果想要默认打印对象中的属性我们可以重写toString
class Student {
String name;
String sex;
int age;
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
@Override
public String toString() {
return "[" + name + "," + sex + "," + age + "]";
}
}
public class Data {
public static void main(String[] args) {
Student student = new Student("小郑","男", 20);
System.out.println(student);
}
}
