Java—面向对象编程、类的基本语法
目录
1、类和对象
2、构造器
3、this关键字
4、封装
5、实体类/Javabean类
6、static关键字
1.static修饰成员变量
2.static修饰方法
3.static注意事项
7、面向对象编程的综合小项目
1、类和对象
面向对象编程：是Java的核心编程。
首先我们先了解一下什么是对象？
对象是一种特殊的数据结构，可以用来记住一个事物的数据，从而代表该事物。
我们了解了对象的结构那么我们怎么定义对象呢？
- 先设计对象的模版，也就是对象的设计图：类。
- 通过new关键字，每new一次就得到一个新对象。
1.类的基本结构：
[访问修饰符] class 类名 {// 成员变量（属性）[访问修饰符] 数据类型 变量名;// 构造器[访问修饰符] 类名(参数列表) {// 构造器体}// 成员方法（行为）[访问修饰符] 返回类型 方法名(参数列表) {// 方法体}
}
2. 访问修饰符
- public：公共访问
- private：私有访问
- protected：受保护访问
- 默认（不写）：包级访问
上面的修饰符我们后面再说。
3. 关键要素
- 类名首字母大写，遵循驼峰命名法
- 成员变量通常设为私有（private）以实现封装
- 提供公共的 getter/setter 方法访问私有成员
- 构造器名与类名相同，无返回类型
- 方法按功能进行合理划分和命名
代码：基于Student类的实例
public class Student {//属性，成员变量String name;int age;double height;//无参构造器//方法public void print(){System.out.println(name + " " + age + " " + height);}
}对象时什么？可以把对象看做一张二维表。
对象在计算机中是啥？
类对象小结：
之前我们对面向对象编程做了解。我们知道面向对象的核心是要设计对象，设计对象就要设计类，所以接下来我们来学习设计类的一些语法
2、构造器
构造器是一种特殊的方法，没有返回值（不需要写）名称和类名想同。在创建对象自动调用。
1. 构造器的定义
- 构造器是一种特殊的方法，用于创建对象时初始化对象状态
- 名称必须与类名完全相同
- 没有返回类型（连 void 都不写）
2. 构造器的特点
- 当使用 new 关键字创建对象时自动调用
- 可以重载（一个类可以有多个构造器）
- 如果没有显式定义构造器，Java会提供默认无参构造器
3. 构造器的优势
- 简化对象创建过程
- 确保对象在创建时就被正确初始化
- 提高代码的可读性和安全性
注意事项：
- 类默认就自带了一个无参构造器
- 如果为类定义了有构造器，类默认的无参构造器就没有了，此时如果还想用无参数构造器，就必须自己写无参数构造器出来。如果只写有参构造器，当使用无参构造器时候就会报错。
下面图片就是一个构造器：无参数构造器
下面我们来看代码：
Student类
public class Student {String name;int age;double height;//有参数构造器public Student(String name , int age , double height){this.name = name; //this语法还没学到这篇文章下面我们会提到this.age = age;this.height = height;}//无参构造器public Student(){System.out.println("无参构造器");}
}
Test类
public class Test {public static void main(String[] args) {// 创建Student对象并初始化基本信息Student s = new Student("张三",18,1.8);//打印student信息System.out.println(s.name + " " + s.age + " " + s.height);//无参数构造器创建Student对象Student s1 = new Student(); //在创建对象时打印：无参构造器//会发现打印出来的是默认值System.out.println(s1.name + " " + s1.age + " " + s1.height);}
}3、this关键字
this就是一个变量，可以用在方法中，来拿到当前对象。说白了那个对象调用这个方法，this就拿到那个对象。
我们通过代码来理解上面这句话。
Student类
public class Student {public void print() {System.out.println(this);}
}
Test类
public class Test {public static void main(String[] args) {// 创建Student对象并初始化基本信息Student s = new Student();s.print();System.out.println(s);}
}
通过打印发现上面两个的地址完全想同，s.print()和下面直接打印s对象的地址相同。说明s对象调用print方法，this就拿到那个对象（的地址）。那么这里this就是s对象。所以可以用this直接找到类中的成员变量。
1. this 的含义
- this 是一个引用当前对象的关键字
- 在实例方法或构造器中，this 指向正在调用该方法或构造器的对象实例
2. this 的主要用途
- 区分成员变量和局部变量（解决变量名称冲突问题的）。
主要用途解决名称冲突问题该怎么使用呢场景是什么？直接看代码注释比较详细
Student类
public class Student {String name;int age;double height;//无参构造器public Student(){}//带参构造器//打印public void print(){System.out.println(name + " " + age + " " + height);}//在定义方法或者构造器时，有时形参名字取起来比较容易和成员变量重名//这里使用this关键字来区分成员变量和形参public Student(String name,int age,double height){//这里使用this关键字来区分成员变量和形参//这里是形参赋值给形参自己
// name = name;这里是形参赋值给形参自己，成员变量name未被修改，不能完成赋值this.name = name;this.age = age;this.height = height;}
}.Test类
public class Test {public static void main(String[] args) {// 创建Student对象并初始化基本信息Student s = new Student("张三", 18, 1.8);s.print();}
}4、封装
面向对象的三大特性：封装、继承、多态。
类就是一种封装
封装的设计要求
合理隐藏，合理暴露
如何隐藏：使用private关键字修饰成员变量，就只能在本类中被直接访问，其他任何地方不能直接访问
private关键字隐藏
- private 是 Java 中的访问修饰符
- 用于限制成员变量、方法或构造器的访问权限
- 被 private 修饰的元素只能在定义它们的类内部访问
下面来看代码如何隐藏，怎么使用。
Student类
public class Student {//属性，成员变量//如何隐藏：使用private关键字修饰成员变量，// 就只能在本类中被直接访问，其他任何地方不能直接访问private String name;private int age;private double height;//2、如何暴露（合理暴露）：使用public修饰的get和set方法合理暴露成员变量//取值和赋值//设置值//为姓名赋值public void setName(String name){this.name = name;}//为年龄属性进行合理的限制public void setAge(int age){if (age >= 0 && age <= 120){this.age = age;}}//为身高属性进行合理的限制public void setHeight(double height){if (height > 0.5 && height < 2.5){this.height = height;}}//取值public String getName(){return name;}public int getAge(){return age;}public double getHeight(){return height;}//方法public void print(){System.out.println(name + " " + age + " " + height);}
}Test类
public class Test {public static void main(String[] args) {// 创建Student对象并初始化基本信息Student s = new Student();s.setName("张三");s.setAge(18);s.setHeight(1.8);s.print();}
}5、实体类/Javabean类
什么叫实体类？
是一种特殊类，类中要满足如下需求
public class Student {//属性，成员变量//如何隐藏：使用private关键字修饰成员变量，// 就只能在本类中被直接访问，其他任何地方不能直接访问private String name;private int age;private double height;//2、如何暴露（合理暴露）：使用public修饰的get和set方法合理暴露成员变量//取值和赋值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 double getHeight() {return height;}public void setHeight(double height) {this.height = height;}//构造器public Student() {}
}实体类有啥应用场景？
下面我们在写一个StudentOperator类来负责对Student类的操作。
下面我们来看一下总的代码：
Student类，学生类Javabean类包含私有的成员变量和get、set方法。
public class Student {//属性，成员变量//如何隐藏：使用private关键字修饰成员变量，// 就只能在本类中被直接访问，其他任何地方不能直接访问private String name;private int age;private double height;//2、如何暴露（合理暴露）：使用public修饰的get和set方法合理暴露成员变量//取值和赋值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 double getHeight() {return height;}public void setHeight(double height) {this.height = height;}//构造器public Student() {}
}StudentOperator类：用于处理Student类定义的对象的操作一些方法。体现了Java中的分层思想。
public class StudentOperator {//我们来写一个类处理Student类创建的对象那我们必须拿到这个对象？//我们现在就需要考虑怎么拿到这个对象private Student s;//用于记住将来操作的学生对象。此时还为null//我们掩考虑怎么把象传递给这个上面的s中？//可以使用有参构造器//构造器public StudentOperator(Student s){this.s = s;}//无参构造器public StudentOperator(){}public void printNamaAndAge(){System.out.println("姓名：" + s.getName() + " 年龄：" + s.getAge());}public void printNamaAndHeight(){System.out.println("姓名：" + s.getName() + " 身高：" + s.getHeight());}
}
Test类：用于测试Student类。
public class Test {public static void main(String[] args) {// 创建Student对象并初始化基本信息Student s = new Student();s.setName("张三");s.setAge(18);s.setHeight(1.8);StudentOperator so = new StudentOperator(s);so.printNamaAndAge();so.printNamaAndHeight();}
}6、static关键字
static关键字，翻译过来叫静态，可以修饰成员变量，成员方法。
1.static修饰成员变量
成员变量按照有无Static修饰，分为两种：
- 静态变量（类变量）：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。
- 实例变量（对象的变量）：无static修饰，属于每个对象
主要特性
1. 静态变量（类变量）
- 使用 static 修饰的变量
- 在内存中只有一份拷贝，被所有实例共享
- 可以通过类名直接访问：ClassName.variableName
2. 静态方法
- 使用 static 修饰的方法
- 可以通过类名直接调用：类名.静态成员变量/静态方法
- 只能直接访问静态成员，不能访问非静态成员
3. 静态代码块
- 用于初始化静态变量
- 在类第一次被加载时执行，且只执行一次
成员变量的执行原理：
接下来看代码：
Student类
public class Student {static String name;int age;
}Test类
public class Test {public static void main(String[] args) {//类名.静态变量(推荐)Student.name = "张三";System.out.println(Student.name);//对象名.静态变量（不推荐）Student s1 = new Student();s1.name = "李四";Student s2 = new Student();s2.name = "王五";System.out.println(s1.name); //这里打印的也是王五，计算机里只有一份，会被类的全部对象共享。System.out.println(Student.name);//实例变量的用法//对象名.实例变量s1.age = 18;s2.age = 19;System.out.println(s1.age);System.out.println(s2.age);
// System.out.println(Student.age);//报错，因为实例变量只能通过对象访问}
}静态变量的使用场景（案例）
如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成静态变量来记住。
下面还是来看代码理解上面的例子：
User类
public class User {public static int count;//构造器public User(){//在类的内部使用成员变量可以直接使用//或者说，访问自己类的成员变量，是可以省略类名的。count++;}
}Test类
public class Test {public static void main(String[] args) {new User();new User();new User();new User();System.out.println(User.count);//4}
}
2.static修饰方法
修饰成员变量按照有无staict分为两类：
- 静态方法：有static修饰的成员方法，这个方法属于类。
- 实例方法： 无static 修饰的成员方法，属于对象。
特点：
- 使用 static 关键字修饰
- 属于类本身，不依赖于类的实例
- 可以通过类名直接调用：类名.方法名()
- 在内存中只有一份，在类加载时就存在
限制：
- 不能直接访问实例变量和实例方法
- 不能使用 this 和 super 关键字
- 只能直接访问其他静态成员
下面来看代码：
Student类
public class Student {private int age;public static void printHalloWorld(){System.out.println("Hallo World");System.out.println("Hallo World");System.out.println("Hallo World");}public void printPass(){if(age > 0 && age < 50){System.out.println("输入合理");}else{System.out.println("输入错误");}}public void setAge(int age){this.age = age;}
}Test类
public class Test {public static void main(String[] args) {//类名.方法名（推荐）Student.printHalloWorld();//对象名.方法名（不推荐）Student s1 = new Student();s1.printHalloWorld();//实例方法 对象名.方法名s1.setAge(20);s1.printPass();//规范：如果这个方法为了做一个功能且不需要直接访问对象的数据，这个方法直接定义成静态方法//如果这个方法是对象的行为，需要访问对象的数据，这个方法必须定义成实例变量}
}
静态方法的使用场景：
Student类
public class verifyCodeUtil {
//构造器定义成私有private verifyCodeUtil(){}public static void getVerifyCode(){String verifyCode = "";for (int i = 0; i < 4; i++){int number = (int)(Math.random() * 10);verifyCode += number;}System.out.println(verifyCode);}
}
工具类
public class Test {public static void main(String[] args) {verifyCodeUtil.getVerifyCode();}
}
为什么工具类中的方法要用静态方法，而不用实例方法？
3.static注意事项
- 静态方法实例方法访问相关的几个注意事项
Test类
public class Test {public static void main(String[] args) {//静态变量}//静态变量public static int count = 10;//实例变量public int a = 10;//静态方法public static void test() {System.out.println(count);
// System.out.println(a); //报错，静态方法不能访问实例变量
// System.out.println(this);//报错，静态方法不能访问this}//实例方法public void test1() {//实例方法可以访问静态变量和实例变量System.out.println(count);System.out.println(a);System.out.println(this);}
}
7、面向对象编程的综合小项目
Movie类
public class Movie {private int id;private String name;private double price;private String actor;//构造器public Movie(){}public Movie(int id, String name, double price, String actor) {this.id = id;this.name = name;this.price = price;this.actor = actor;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public String getActor() {return actor;}public void setActor(String actor) {this.actor = actor;}
}
MovieOperator类
public class MovieOperator {private Movie[] movies;//构造器public MovieOperator(Movie[] movies) {this.movies = movies;}public void printAllMovies() {for (int i = 0; i < movies.length; i++) {System.out.println("id" + movies[i].getId()+"name->:" + movies[i].getName() +"price->" +movies[i].getPrice() +"actor->" +movies[i].getActor());}}public void searchMovieById() {System.out.println("请输入要查询的id");Scanner sc = new Scanner(System.in);int e = sc.nextInt();for (int i = 0; i < movies.length; i++) {if (movies[i].getId() == e) {System.out.println("id" + movies[i].getId()+"name->:" + movies[i].getName() +"price->" +movies[i].getPrice() +"actor->" +movies[i].getActor());return;}}System.out.println("没有找到该电影");}}Test类
public class Test {public static void main(String[] args) {//1、设计电影类Movie，以便创建电影对象，封装电影数据//2、封装系统中的全部电影信息，并保存在数组中（自己造）Movie []movies = new Movie[6];movies[0] = new Movie(1,"唐顿庄园",6.5,"罗宾·怀特");movies[1] = new Movie(2,"速度与激情",9.5,"瑞秋");movies[2] = new Movie(3,"夏洛特烦恼",9.5,"沈腾");movies[3] = new Movie(4,"战狼2",7.5,"吴京");movies[4] = new Movie(5,"让子弹飞",8.5,"姜武");movies[5] = new Movie(6,"暗战",9.1,"王大陆");//3、创建电影操作对象出来，专门负责电影数据的业务操作。MovieOperator mo = new MovieOperator(movies);System.out.println("------------------全部电影信息如下----------------");mo.printAllMovies();System.out.println("------------------所查询的电影-------------");mo.searchMovieById();}
}上面的代码利用了对象的声明和初始化，其实和基本类型的数组没有什么差别。只是数组中元素比变为数组中的每个元素只是对象引用，而非实际对象实例。
OK文章到这里就结束了，作者能力有限。如果文章出现错误或者歧义欢迎大家在评论区指出。