一、面向对象编程快速入门
1.开发一个一个的对象，把数据交给对象，再调用对象的方法来完成对数据的处理
2.面向对象编程有啥好处？
符合人类思维习惯，编程更简单、更直观
3.程序中的对象怎么理解？
- 对象本质上是一种特殊的数据结构。相当于现实生活中的一张表。比如s1的学生表，s2的学生表
4.对象是怎么出来的？
下面第一个代码：（class student -----> 学生表）
- class也就是类，也称为对象的设计图（或者对象的模板）
package object;
public class Student {
String name;
double chinese;
double math;
public void printTotalScore(){
System.out.println(name + "的总成绩是：" + (chinese + math));
}
public void printAverageScore(){
System.out.println(name + "的平均成绩是：" + (chinese + math) / 2.0);
}
}
package object;
public class Test {
public static void main(String[] args) {
// 目标：面向对象编程快速入门
// 1. 创建一个学生对象，封装波妞的数据
Student s1 = new Student();
s1.name = "波妞";
s1.chinese = 100;
s1.math = 100;
s1.printTotalScore();
s1.printAverageScore();
// 2. 再创建一个学生对象，封装波仔的数据
Student s2 = new Student();
s2.name = "波仔";
s2.chinese = 59;
s2.math = 100;
s2.printTotalScore();
s2.printAverageScore();
}
}二、对象在计算机中的执行原理
-
Student s1 = new Student（）；
- 每次new Student（），就是在堆内存中开辟一块内存区域代表一个学生对象
- s1变量里面记住的是学生对象的地址
如何识别引用类型的变量？
- Student s1 = new Student（）；
- s1变量中存储的是对象的地址，因此变量s1也称为引用类型的变量
三、类和对象的一些注意事项
1.类名建议用英文单词，首字母大写，满足驼峰模式，且要有意义，比如：Student、Car...
2.类中定义的变量也称为成员变量（对象的属性），类中定义的方法也称为成员方法（对象的行为）。
3.成员变量本身存在默认值，在定义成员变量时一般来说不需要赋初始值（没有意义）。
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| 基本类型 | byte、short、char、int、long | 0 |
| float、double | 0.0 | |
| boolean | false | |
| 引用类型 | 数组、String | null |
修饰符 数据类型 变量名称 = 值；
4.一个代码文件中，可以写多个class类，但只能一个用public修饰，且public修饰的类名必须称为代码文件名。
5.对象与对象之间的数据不会相互影响，但多个变量指向同一个对象时就会相互影响了
6.如果某个对象没有一个变量引用它，则该对象无法被操作，该对象会称为所谓的垃圾对象
- 注意：当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。
- Java存在自动垃圾回收机制，会自动清除掉垃圾对象
package object;
public class Test2 {
public static void main(String[] args) {
// 目标：掌握类与对象的一些注意事项
// 1.类名建议用英文单词，首字母大写，满足驼峰模式，且要有意义，比如：Student、Car...
// 2.类中定义的变量也称为成员变量（对象的属性），类中定义的方法也称为成员方法（对象的行为）。
// 3.成员变量本身存在默认值，在定义成员变量时一般来说不需要赋初始值（没有意义）。
Student s = new Student();
System.out.println(s.name); //null
System.out.println(s.math); //0.0
System.out.println(s.chinese); //0.0
// 4.一个代码文件中，可以写多个class类，但只能一个用public修饰，且public修饰的类名必须称为代码文件名。
// 5.对象与对象之间的数据不会相互影响，但多个变量指向同一个对象时就会相互影响了
Student s1 = new Student();
s1.name = "张三";
// Student s2 = new Student();
// s2.name = "李四";
// 把s1变量中存储的学生对象的地址赋值给了s2变量
Student s2 = s1;
s2.name = "李四"; // 此时下面s1输出的结果就是李四
System.out.println(s1);
// 6.如果某个对象没有一个变量引用它，则该对象无法被操作，该对象会称为所谓的垃圾对象
//s1 = null;
//s2 = null;
//System.out.println(s1.name);//此时这个就会报错，空指针异常
}
}
四、构造器
1.构造器是什么样子？
public class Student{
// 构造器
public Student(){
...
}
}2.构造器的特点
- 创建对象时，对象会去调用构造器。
Student s = new Student();3.构造器的常用场景
- 创建对象时，同时完成对对象成员变量（属性）的初始化赋值
4.构造器的注意事项
- 类在设计时，如果不写构造器，Java是会为类自动生成一个无参构造器。
- 一旦定义了有参数构造器，Java就不会帮我们的类自动生成无参构造器了，此时就建议自己手写一个无参构造器出来了。
package constructor;
public class Teacher {
public Teacher(){
// 所以最后每次写构造器都要习惯去写无参数构造器
}
public Teacher(String name){
// 一旦有了参数构造器，那么无参数构造器就会自动消除，测试test中就不能有无参数构造器的引用
}
}package constructor;
public class Student {
String name;
double score;
// 无参数构造器
public Student(){
System.out.println("无参数构造器被触发执行了~~");
}
// 有参数构造器
public Student(String name, double score){
System.out.println("有参数构造器被触发执行了~~");
this.name = name;
this.score = score;
}
}
package constructor;
public class Test {
// 目标:认识构造器，并掌握构造器的特点、应用场景、注意事项。
public static void main(String[] args) {
Student s1 = new Student("波仔",99);
Student s = new Student();
s.name = "波妞";
s.score = 100;
// 这种方式如果要有100个数据都要一个一个填很麻烦
// 使用构造器会更便利
Student s2 = new Student("小黑",59);
System.out.println(s2.name);
System.out.println(s2.score);
System.out.println("--------------");
//Teacher t = new Teacher(); // 即使没有构造器java会自动创造一个无参数构造器
}
}
五、this
1.this是什么？
- this就是一个变量，可以用在方法中，来拿到当前对象
2.this的应用场景
- this主要用来解决：变量名称冲突问题的
package thisdemo;
public class Student {
double score;
public void printThis(){
System.out.println(this);
}
public void printPass(double score){
if(this.score > score ){
System.out.println("恭喜您，您成功考入了哈佛大学~~");
}else{
System.out.println("落选了~~");
}
}
}
package thisdemo;
public class Test {
// 目标：认识this，掌握this的应用场景
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1);
s1.printThis();
System.out.println("----------------");
Student s2 = new Student();
System.out.println(s2);
s2.printThis();
System.out.println("-----------------");
Student s3 = new Student();
s3.score = 325;
s3.printPass(250);
}
}六、封装
1.什么是封装？
- 就是用类设计对象处理某一个事物的数据时，应该把要处理的数据，以及处理这些数据的方法，设计到一个对象中去
- 面对对象的三大特征：封装、继承、多态
2.封装的设计规范
- 合理隐藏、合理暴露
3.代码层面如何控制对象的成员公开或隐瞒？
- 公开成员，可以使用public（公开）进行修饰
- 隐藏成员，使用private（私有，隐藏）进行修饰
package encapsulation;
public class Student {
// private double score;
//
// private void printPass(){
// System.out.println(score >= 60 ? "成绩合格" : "成绩不合格");
// }
// 加上private关键字来修饰 以上两个成员：score、printPass就被隐藏了
// 被隐藏后只能在Student内部访问，去Test外部就访问不了
// 下面这样完全暴露容易被乱修改
// public double score;
//
// public void printPass(){
// System.out.println(score >= 60 ? "成绩合格" : "成绩不合格");
// }
// 以下可以合理隐藏、合理暴露
private double score;
public void setScore(double score){
// 存入数据
// 使用if语句判断存入的数据是否合不合理
if(score >= 0 && score <= 100){
this.score = score;
}else{
System.out.println("数据非法~~");
}
}
// 提取数据,外部提取内部score的方法
public double getScore(){
return score;
}
public void printPass(){
System.out.println(score >= 60 ? "成绩合格" : "成绩不合格");
}
}package encapsulation;
public class Test {
public static void main(String[] args) {
// 目标：掌握封装的设计规范：合理隐藏、合理暴露
Student s1 = new Student();
// s1.score 此时这样打出score就会报错
// 然后重新将Student前面的修饰符改成public又不会报错，但是很容易被人乱修改，比如：
//s1.score = -99;// 乱修改
// 现实业务开发中更需要能公开但不能修改的需求
s1.setScore(99);
System.out.println(s1.getScore());
}
}
七、实体javaBean
1.什么是实体类？
- 就是一种特殊形式的类---就是保存某个事物的数据
（1）这个类中的成员变量都要私有，并且要对外提供相应的getXXX，setXXX方法
（2）类中必须要有一个公共的无参的构造器
2.实体类有啥应用场景？
- 实体类只负责数据存取，而对数据的处理交给其他类来实现，以实现数据和数据业务处理相分离
package javabean;
public class Test {
public static void main(String[] args) {
// 目标：掌握实体类的书写要求、特点、应用场景
Student s1 = new Student();
s1.setName("波妞");
s1.setScore(99);
System.out.println(s1.getName());
System.out.println(s1.getScore());
StudentOperator operator = new StudentOperator(s1);
operator.printPass();
}
}
package javabean;
public class Student {
// 1. 必须私有成员变量，并为每个成员变量都提供get set方法
private String name;
private double score;
// 2. 必须为类提供一个公开的无参数构造器
public Student() {
}
public Student(String name, double score) {
this.name = name;
this.score = score;
}
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 Student {
// 1. 必须私有成员变量，并为每个成员变量都提供get set方法
private String name;
private double score;
// 2. 必须为类提供一个公开的无参数构造器
public Student() {
}
public Student(String name, double score) {
this.name = name;
this.score = score;
}
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;
}
}
八、面向对象编程综合案例
1.模仿电影信息系统
需求：
- 展示系统中的全部电影（每部电影展示：名称、价格）.
- 允许用户根据电影编号（id）查询处某个电影的详细信息
目标：
- 使用所学的面向对象编程实现以上2个需求
代码：
package demo;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 目标：完成电影信息展示功能；根据电影id查询该电影详情
/**
* 电影数据：
1. ”水门桥“，38.9， 9.8 ，”徐克“, "吴京”， “12万人想看”
2. “出拳把”， 39， 7.8， “唐晓白”， “田鱼”， “3.5万人想看”
3. “月球陨落”， 42， 7.9， “罗兰”， “贝瑞”， “17.9万人想看”
4. ”一点就到家“， 35， 8.7， ”许宏宇“， ”刘昊然“， ”10.8万人想看“
*/
// 1. 设计一个电影类Movie
// 2. 设计一个电影的操作类MovieOpertor
// 3. 准备 全部电影资源
Movie[] movies = new Movie[4];
movies[0] = new Movie(1,"水门桥",38.9, 9.8, "徐克", "吴京", "12万人想看");
movies[1] = new Movie( 2, "出拳把", 39, 7.8, "唐晓白", "田鱼", "3.5万人想看");
movies[2] = new Movie(3, "月球陨落", 42, 7.9, "罗兰", "贝瑞", "17.9万人想看");
movies[3] = new Movie(4, "一点就到家", 35, 8.7, "许宏宇", "刘昊然", "10.8万人想看");
// 4. 创建一个电影操作类的对象，接收电影数据，并对其进行业务处理
MovieOperator operator = new MovieOperator(movies);
operator.printAllMovies();
operator.searchMovieById(3);
Scanner sc = new Scanner(System.in);
while (true) { //放入死循环中，输不对就继续输
System.out.println("==电影信息系统==");
System.out.println("1、查询全部电影信息");
System.out.println("2、根据id查询某个电影的详细信息展示");
System.out.println("请您输入操作命令：");
int command = sc.nextInt();
switch (command){
case 1:
// 展示全部电影信息
operator.printAllMovies();
break;
case 2:
// 根据id查询某个电影的详细信息展示
System.out.println("请您输入查询的电影id：");
int id = sc.nextInt();
operator.searchMovieById(id);
break;
default:
System.out.println("您输入的命令有问题~~");
}
}
}
}
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;
public class MovieOperator {
private Movie[] movies;
public MovieOperator(Movie[] movies){
this.movies = movies;
}
// 1. 展示系统全部电影信息 movies = [m1, m2, m3, ...]
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("----------------------");
}
}
// 2. 根据电影的编号查询出该电影的详细信息并展示
public void searchMovieById(int id){
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i] ;
if(m.getId() == id){
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 variable;
public class Student {
// 成员变量（对象的属性,field）
String name; // 有默认值null
double score; // 有默认值0.0
public void aaa(){
double score = 98;
System.out.println(score);//98局部变量
System.out.println(this.score);//当前student对象的前变量score
}
}
package variable;
public class Test {
public static void main(String[] args) {
// 目标：搞清楚 成员变量和 局部变量的区别
// 1.类中位置不同 ：类中，方法外 常见于方法中
int a = 20;
// 2.初始化值不同 ：有默认值，不需要初始化赋值 没有默认值，使用之前必须完成赋值
// int b;
// System.out.println(b); //局部变量没有默认值会报错
// 3.内存位置不同 ：堆内存 栈内存
// 4.作用域不同： 整个对象 在所归属的大括号中
String name = "heima"; // 这个局部变量只在该类的 17行-大括号 中有效
// 5.生命周期不同：与对象共存亡 随着方法的调用而生，随着方法的运行结束而亡
}
}
扫一扫
1571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
