面向对象是java编程的套路。更符合人类思维习惯，编程更直观。面向对象有三大特征：封装，继承，多态。
目录
1.理解面向对象
（开发一个一个的对象，把数据交给对象，再调用对象的方法来完成对数据的处理。）
*1.*类（Class）：类是创建对象的模板或蓝图。它定义了对象的属性和方法。属性是对象的特征（如学生的姓名，成绩），而方法是对象可以执行的操作（如计算总分和平均成绩）。
2. 对象（Object）：对象是类的实例。通过类，我们可以创建多个具有相同属性和方法的对象，但每个对象可以有不同的属性值。
下面是举一个学生的类(模板)以及测试Text中创建好的对象。
import java.net.SocketOption;
public class Student { //这是我们创建好的一个类
String name; //这是类的属性
double Chinese;
double Math;
//这是类的方法
public void printfTotalScore(){
System.out.println(name+"的总成绩"+(Chinese+Math));
}
public void printfAverageScore(){
System.out.println(name+"的平均成绩"+((Chinese+Math)/2.0));
}
}
public class Text1 {
public static void main(String[] args) {
Student s1 = new Student();
s1.name = "楠楠";
s1.Chinese = 100;
s1.Math = 100;
s1.printfTotalScore();
s1.printfAverageScore();
Student s2 = new Student(); //对象都是类new出来的
s2.name = "王强";
s2.Chinese = 13;
s2.Math = 14;
s2.printfTotalScore();
s2.printfAverageScore();
}
}
参照黑马的讲解，是将类比作一张空白的表格，而每个对象是已经填好数据的表。
| 姓名 | null |
| 数学 | 0 |
| 语文 | 0 |
| ..... |
| 姓名 | 楠楠 |
| 数学 | 100 |
| 语文 | 100 |
| ..... |
2.对象在计算机中的执行原理
这是参照黑马绘制的执行流程 。还是区分代码什么部分在虚拟机内存中什么位置运行。
引用类型
- Student s1 = new Student();
- s1变量中存储的是对象的地址，因此变量s1也称为引用类型的变量。
3.类和对象的一些注意事项
- 类名建议用英文单词，首字母大写，满足驼峰模式，且要有意义，类如：Student，Car
- 类中定义的变量也称为成员变量（对象的属性），类中定义的方法也称成员方法（对象的行为）。
- 成员变量本身存在默认值，同学们在定义变量时一般来说不需要赋初始值（没有意义）
数据类型 明细 默认值 基本类型 byte.short.char.int .long 0 float.double 0.0 boolean false 引用类型 数组,String null - 一个代码文件中，可以写多个class类，但只能一个用public修饰，且public修饰的类名必须成为代码文件名。
- 对象会和对象之间的数据不会相互影响，但是多个变量指向同一个对象时就会相互影响了。（定义好s1后，再让 s2 = s1，修改s2就会影响s1。 ）
- 如果某个对象没有一个变量引用它，则该对象无法被操作了，该对象会成为所谓的垃圾对象。会被清除。
4.类与对象的一些语法知识
（1）this关键字
this是一个变量，可以用在方法中，来拿到当前对象。主要用来解决变量名称的冲突问题。
import java.net.SocketOption;
public class Student {
public void prrintthis(){
System.out.println(this);
}
}
public class Text2 {
public static void main(String[] args) {
//目标：认识this，掌握this的应用场景
Student s1 = new Student();
System.out.println(s1);
s1.prrintthis();
System.out.println("________________________");
Student s2 =new Student();
System.out.println(s2);
s2.prrintthis();
}
}
this的执行原理：在方法区调用this时，堆内存会把当前对象的地址传给this。（执行图省略）
this的应用场景
在解决形参变量名和类中变量名冲突的问题时还可以修改形参名来解决，但是使用this更符合编码规范。
（2）构造器
（本质一个与类名相同的方法）
public class Student{
public Student(){
.....
}
}构造器的特点
创建对象时，对象会去调用构造器。
Student s = new Syudent(); //验证构造器触发的代码
package constructor;
public class Student {
//无参数构造器
public Student(){
System.out.println("无参数构造器被触发执行了");
}
//有参数构造器
public Student(String name,double score){
System.out.println("有参数构造器被触发执行了");
}
}
package constructor;
public class Tsxt {
public static void main(String[] args) {
//目标：认识构造器，并掌握构造器的特点，应用场景，和注意事项
Student s = new Student();
//Student s = new Student("楠楠”，100);
}
}
构造器的常见应用场景
创建对象时，同时完成对对象成员变量(属性)的初始化赋值。
不使用构造器时，进行变量赋值，如果变量数量比较多，赋值就不太方便。
使用构造器时，就可以在完成创建的同时完成赋值。
构造器的注意事项
- 类在设计时，如果不写构造器，java会自动生成一个无参构造器的。
- 一旦有了有参构造器，JAVA就不会帮我们的类自动生成无参构造器了。此时就建议自己手写一个无参构造器出来。
（3）封装
封装是将对象的数据（属性）和操作数据的方法（行为）结合起来，形成一个独立的单元。通过封装，可以隐藏对象的内部实现细节，只对外提供有限的接口（即方法），从而提高了代码的安全性和可维护性。
（就是把类设计对象处理某一个事物的数据时应该把要处理的数据以及处理这些数据的方法涉及到一个对象中去。）
封装的设计规范 合理隐藏 合理暴露
前提补充：所谓隐藏与暴露，实际是类中修饰词 public（公开） 和 private（私有） 的使用。
像这里，将类中的score修饰为 pivate 后，再在外部调用就会报错。（类内部还是可以正常使用的）这里对于这个成绩，我们会发现如果暴露，可能会导致有随意赋值的情况产生，但是隐藏，又无法达到赋值成绩实现功能的目的。所以，为了合理隐藏和合理暴露，就要采用方法的手段。
package encapsulation;
public class student {
private double score;
public void setScore(double score){
if(score>=0 && score<= 100){
this.score = score;
}
else {
System.out.println("数据非法");
}
}
private double getScore(){
return score;
}
public void printPass(){
System.out.println(score >=60 ?"成绩合格":"成绩不合格");
}
}
像这样，并不直接将数据暴露，而是只暴露修改函数，通过函数来修改值，这里我们还可以写代码来限制和判断输入数据的合法性。这是对于的成员变量的合理隐藏，合理暴露的操作，而对于方法而言，只需要看是否需要被外界访问，需要则公开，不需要则隐藏。
快捷构造get，set函数
1.在IDEA代码界面右键，选中 生成
2.生成界面选择 Getter 和 Setter
3. 弹出界面后选择要生成函数的成员名称（按住shift键可以进行多选）
4.最后确定完成
快捷生成构造器
1.和上述一致，打开生成界面 选择 构造函数 （Constructor）
2.选择构造函数要传参的成员变量，如果选择无参数类型的，选择无。
（4）实体javaBean （实体类）
实体类是一种特殊形式的类。这个类中的成员变量都要私有，并且要对外提供相应的getXXX和setXXX方法。类中必须要有一个公共的无参的构造器。
package javaBean;
public class Student {
//1.必须私有变量，并为每个都要提供 get set 方法
private String name;
private double score;
//2.必须为类提供一个公开的无参数的构造器
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
package javaBean;
public class Text {
public static void main(String[] args) {
//目标:掌握实体类的书写要求，特点，应用场景。
Student s = new Student();
s.setName("楠楠");
s.setScore(100);
System.out.println(s.getName());
System.out.println(s.getScore());
}
}
实体类的特点 只有为了存储某个类的数据。
实体类的应用场景 一个类中封装了太多方法时，开辟实体类，只负责数据存储，而对数据的处理交给其他类来完成，已实现数据和数据业务处理相分离。（这种开发方式比较流行）
package javaBean;
public class Student {
//1.必须私有变量，并为每个都要提供 get set 方法
private String name;
private double score;
//2.必须为类提供一个公开的无参数的构造器
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
class Studentperator{
private Student student;
public Studentperator( Student student){
this.student = student;
}
public void printPass(){
if(student.getScore() >= 60){System.out.println(student.getName()+"成绩及格");}
else {System.out.println(student.getName()+"成绩不及格");}
}
}
5.面向对象编程的综合案例
需求： 1.展示系统中的全部电影（每部电影展示：名称 ，价格）
2.允许用户根据电影编号（id）查询某个电影的详细信息
package Demo;
public class Movie {
private int id;
private String name;
private double price;
private double score;
private String director;
private String actor;
private String info;
public Movie() {
}
public Movie(int id, String name, double price, double score, String director, String actor, String info) {
this.id = id;
this.name = name;
this.price = price;
this.score = score;
this.director = director;
this.actor = actor;
this.info = info;
}
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 double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
package Demo;
import java.sql.SQLOutput;
public class MoivePerator {
private Movie[] movies;
public MoivePerator(Movie[] movies){
this.movies = movies;
}
//展示系统全部信息
public void printAllMovies(){
System.out.println("———————————系统全部电影信息——————————");
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i];
System.out.println("编号："+ m.getId());
System.out.println("名称："+ m.getName());
System.out.println("价格："+ m.getPrice());
System.out.println("_________________________________");
}
}
public void searchMovieByid(int id){
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i];
if (m.getId() == id) {
System.out.println("___________该电影的详细信息___________");
System.out.println("编号：" + m.getId());
System.out.println("名称：" + m.getName());
System.out.println("价格：" + m.getPrice());
System.out.println("得分：" + m.getScore());
System.out.println("导演：" + m.getDirector());
System.out.println("主演：" + m.getActor());
System.out.println("其他信息：" + m.getInfo());
return; //已经找到
}
System.out.println("没有该电影信息");
}
}
}
package Demo;
import java.util.Scanner;
public class Text {
public static void main(String[] args) {
//1.设计一个电影类
//2.设计一个电影操作类
//3.准备 全部电影数据
Movie[] movies = new Movie[4];
movies[0] = new Movie(1,"1",1,1,"1","1","1");
movies[1] = new Movie(2,"1",1,1,"1","1","1");
movies[2] = new Movie(3,"1",1,1,"1","1","1");
movies[3] = new Movie(4,"1",1,1,"1","1","1");
MoivePerator mp = new MoivePerator(movies);
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("==电影信息查询==");
System.out.println("==1.全部信息查询==");
System.out.println("==2.id查询信息==");
int command = sc.nextInt();
switch (command) {
case 1:
mp.printAllMovies();
break;
case 2:
System.out.println("请输入您要查询的电影id");
int id = sc.nextInt();
mp.searchMovieByid(id);
break;
default:
System.out.println("输入错误 请重新输入");
}
}
}
}
6.*补充：成员变量,局部变量的区别
| 区别 | 成员变量 | 局部变量 |
| 类中位置不同 | 类中，方法中 | 常见方法中 |
| 初始化值不同 | 有默认值，不需要初始化赋值 | 没有默认值，使用之前必须完成赋值 |
| 内存位置不同 | 堆内存 | 栈内存 |
| 作用域不同 | 整个对象 | 在所归属的大括号内 |
| 生命周期不同 | 与对象共存亡 | 随着方法的调用而生，随着方法的运行而结束 |
7.总结
学习时间：2024.7.31
标签：JAVA,Student,基础,System,String,面向对象编程,println,public,out From： https://blog.csdn.net/Hismybestlove/article/details/140821265