当前位置： 首页 > ds >正文

Java-面向对象-类与对象（基础）

ds 2025/7/16 17:37:31

前言

继Java前置基础继续学习学习

1.面向过程的思维

把大象放冰箱里需要几步?

2.面向对象的编程

3.类与对象

类是对一类事物的抽象

对象是“真实存在的”

4.类的声明结构

属性就是成员变量

方法就是函数

类已经下面创建好的，下面就是类似造房的图纸

public class Person {String name;int age ;public void speak() {System.out.println("i'am person");}public void eat(){System.out.println("i'am eating");}
}

如何让图纸不再是纸上，而成为真实的楼房呢

5.基于类创建（实例化）对象

基于类实例化一个对象

public class Test {public static void main(String[] args) {//基于Person类实例化一个Person对象Person P = new Person();}
}

6.如何调用对象的属性和方法

public class Test {public static void main(String[] args) {//基于Person类实例化一个Person对象Person p = new Person();p.name ="test";p.age =18;System.out.println(p.name);System.out.println(p.age);p.speak();p.eat();}
}

然后开始运行

public class Test2 {public static void main(String[] args) {Person p1  = new Person();Person p2  = new Person(); //malloc  动态内存分配p1.name = "john";p2.name = "jane";p1=p2;p2.name = "jack";System.out.println(p1.name);System.out.println(p2.name);}
}

发现运行结果为

为什么会这样呢，虽然java里面没有指针的概念，但是有引用这个说法

然后结果

public class Test3 {public static void main(String[] args) {Person person = new Person();person.name="关羽";fun(person);System.out.println(person.name);}
//引用传递public static void fun(Person person){person.name ="张飞";System.out.println(person.name);}
}

发现输出结果依旧是两个张飞

分析可以发现，这里是引用传递，这是引用数据类型决定的

public class Test4 {public static void main(String[] args) {int a =5;fun(a);System.out.println(a);}
//值传递public static void fun(int b) {b=10;System.out.println(b);}
}

这是值传递，这是基本数据类型决定，所以不存在什么引用

可以发现其执行顺序是代码往下走，然后先执行输出b,再执行输出a

7.一个实例演示对象在游戏当中的作用

Hero类

public class Hero {String name;double red;double blue;double attack;double attackSpeed;double moveSpeed;Weapon w;public  void PuAttack(){System.out.println(name + " 使用 " + w.name + " 发动攻击！");System.out.println("攻击伤害:"+ attack*attackSpeed);}public  void setWeapon(Weapon weapon){w = weapon;attack+=w.attack;attackSpeed+=w.attackSpeed;}
}

Weapon类

public class Weapon {String name;double attack;double attackSpeed;}

Test5类

public class Test5 {public static void main(String[] args) {Weapon w = new Weapon();w.name = "泣血之刃";w.attack = 500;w.attackSpeed =10;Hero h = new Hero();h.name ="亚瑟";h.attack =1000;h.attackSpeed =5;h.red =5000;h.blue =0;h.moveSpeed =10;h.setWeapon(w);h.PuAttack();}}

运行结果

一些作业

求长方体周长

public class Rectangle {double width;double height;public  void area(){System.out.println("面积为:" + (width * height));}public void perimeter(){System.out.println("周长为:" + (width + height) * 2);}}

public class TestRavtangle {public static void main(String[] args) {Rectangle r = new Rectangle();r.height =5;r.width=10;r.area();r.perimeter();}
}

求圆

public class Circle {double radius;public void area(){System.out.println("面积为:" + 3.14 * radius * radius);}public void  perimeter(){System.out.println("周长为" + 2 * 3.14 * radius);}
}

public class TestCircle {public static void main(String[] args) {Circle c = new Circle();c.radius =2.5;c.area();c.perimeter();}
}

用类演示打枪

public class Gun {String name;public  void shoot(){System.out.println("突突突突突突");}
}

public class Person {String name;Gun gun;public  void attack(String _name){System.out.println(name + "用" + gun.name + "打了" + _name);gun.shoot();}}

public class Test {public static void main(String[] args) {Gun gun = new Gun();gun.name = "98k";Person p1 = new Person();Person p2 = new Person();p1.name = "小王";p2.name = "小李";p1.gun = gun;p1.attack(p2.name);}
}

8.private_set_get_构造方法

不给其赋值就有默认值

public class DefaultValue {boolean a;char b;byte c;short d ;int e ;long f ;float g ;double h;String i;
}

public class TestDefault {public static void main(String[] args) {DefaultValue d = new DefaultValue();System.out.println(d.a);System.out.println(d.b);System.out.println(d.c);System.out.println(d.d);System.out.println(d.e);System.out.println(d.f);System.out.println(d.g);System.out.println(d.h);System.out.println(d.i);}
}

9.属性成员变量私有化

public class Person {private String name;private  int age;
}

public class Test {public static void main(String[] args) {Person p = new Person();p.name ="jack";}
}

结果发现报错了

这时候就需要有ste,get方法了

Person类

public class Person {private String name;private  int age;public void setName(String _name){name = _name;}public String getName(){return  name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

public class Test {public static void main(String[] args) {Person p = new Person();p.setName("jack");p.setAge(20);System.out.println(p.getName());System.out.println(p.getAge());}
}

10.this关键字

public class Person {private String name;private  int age;public void setName(String _name){this.name = _name;}public String getName(){return  name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

然后运行即可

11.构造方法

构造方法的名字与类名相同，该方法没有返回值，也不使用void关键字。构造方法用来创建对象，如果在类中没有显示的声明构造方法，默认会提供一个空的构造方法。

public class Person {public Person(){//constructorSystem.out.println("这里是构造方法");}}

public class Test {public static void main(String[] args) {Person p = new Person();}
}

12.vo/javaBean/pojo/entity

在数据库里面，一个关系就是一张表

所以er图也叫做实体图，全称为entity-relationship图

拓展

其中还有ORMapping

就是一个对象对应着Java类当中的匹配

一个Java类对应着一张数据库表，一个Java内的对象对应着表中的一条记录，一个类当中的属性，对应着表当中的一个字段

OOP（面向对象编程）

就是顾名思义跟数据库映射用的

13.方法重载

一个类中的多个方法，方法名相同参数不同

public class Test {public static void main(String[] args) {fun(5,6);}public static void fun(int a,int b){System.out.println(a + b);}
}

然后方法重载可以不是全都是int的

public class Test {public static void main(String[] args) {fun(5,6);}public static void fun(int a,int b){System.out.println(a + b);}public static void fun(int a,double b){}
}

构造方法的重载

我们再继续来一个实例

public class Person {private String name;public Person(String name, int age) {this.name = name;this.age = age;}private  int age;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;}
}

然后一个main函数

public class TestPerson {public static void main(String[] args) {Person person = new Person("张飞",30);System.out.println(person.getName());System.out.println(person.getAge());}
}

然后空方法重载

public class Person {private String name;private  int age;//构造方法的重载public Person(){}public Person(String name, int age) {this.name = name;this.age = age;}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;}
}

14.static_package_import_继承

15.static关键字

Person类

public class Person {private  String name;public int count = 0;public  Person(){count++;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

Test主类

public class Test {public static void main(String[] args) {Person p1 = new Person();Person p2 = new Person();System.out.println(p1.count);System.out.println(p2.count);}
}

发现都运行了一次

public class Person {private  String name;public static int count = 0;//添加的地方public  Person(){count++;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

此时我们再添加一个static，然后再次运行，然后就变两次了

public class Test {public static void main(String[] args) {Person p1 = new Person();Person p2 = new Person();System.out.println(Person.count);//}
}

此时改变的地方

一个Tips，避免实际开发中代码的难修改，我们常会新建一个工具类，里面会调用其中代码，然后易于修改

public class Test2 {public static void main(String[] args) {//高内聚低耦合Person p = new Person();p.setSex(Util.MALE);}
}

工具类，实际上可能需要添加 final关键字修饰

public class Util {public static int MALE = 1;public static int FEMALE =0;}

16.包（package）

示例代码演示

package com.project.test;public class Animal {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}
}

17.import

同一包下

package com.project.test;public class Animal {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}
}

发现没有import进行引用

package com.project.test;
public class TestAnimal {public static void main(String[] args) {Animal animal = new Animal();}}

不同包下，需要import关键词进行导入

package com.project.test1;import com.project.test.Animal;public class Test {public static void main(String[] args) {Animal a = new Animal();}
}

不用import关键字导入

package com.project.test1;public class Test {public static void main(String[] args) {com.project.test.Animal a = new com.project.test.Animal();}
}

java.lang底下不用，也就是说system.out.println()不用

18.继承

Person类

package com.project.extend;public class Person  {private  String name;private  int age ;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 void info(){System.out.println("Name: " + name + "Age: " + age);}}

Student类

package com.project.extend;public class Student extends Person {private String school;public String getSchool() {return school;}public void setSchool(String school) {this.school = school;}
}

主类

package com.project.extend;public class Test {public static void main(String[] args) {Student s = new Student();s.setName("张三");s.setAge(20);s.setSchool("希望小学");s.info();}
}

19.方法的重写/覆写(overwrite/override)

重写后的类型

Person类

package com.project.extend;public class Person  {private  String name;private  int age ;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 void info(){System.out.println("Name: " + name + "Age: " + age);}}

Student类

package com.project.extend;public class Student extends Person {private String school;public void info(){//超类，基类System.out.println(" Name: " + this.getName() + " Age: " + super.getAge()+" School: "+ this.getSchool());}public String getSchool() {return school;}public void setSchool(String school) {this.school = school;}
}

主类

package com.project.extend;public class Test {public static void main(String[] args) {Student s = new Student();s.setName("张三");s.setAge(20);s.setSchool("希望小学");s.info();}
}

运行结果

20.父子类继承中构造方法的调用

演示实例

这是父类

package com.project.extend;public class Person  {private  String name;private  int age ;public   Person(){System.out.println("Person constructor");}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 void info(){System.out.println("Name: " + name + "Age: " + age);}}

这是子类

package com.project.extend;public class Student extends Person {private String school;public Student(){System.out.println("Student Constructor");}public void info(){//超类，基类System.out.println(" Name: " + this.getName() + " Age: " + super.getAge()+" School: "+ this.getSchool());}public String getSchool() {return school;}public void setSchool(String school) {this.school = school;}
}

主函数

package com.project.extend;public class Test1 {public static void main(String[] args) {Student s1 = new Student();}
}

运行进行查看

发现先调用了父类方法，再调用了子类方法

演示图

带参数的构造方法

public  Person(String name,int age){this.name= name;this.age = age;
}

发现student报错

然后解决方法

public Student(String name,int age,String school){super(name,age);
}

然后继续解决方法

package com.project.extend;public class Test {public static void main(String[] args) {Student s = new Student("张三",20,"希望小学");
//        s.setName("张三");
//        s.setAge(20);
//        s.setSchool("希望小学");s.info();}
}

作业

学生类

package com.kjxy.homework;public class Student {private String name;private int age ;public Student(String name, int age) {this.name = name;this.age = age;}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 void info(){}}

UnderGraduate类

package com.kjxy.homework;public class UnderGraduate extends Student{private String major;public UnderGraduate(String name, int age, String major) {super(name, age);this.major = major;}public String getMajor() {return major;}public void setMajor(String major) {this.major = major;}@Overridepublic void info() {super.info();System.out.println("name:" + this.getName() + "age:" + this.getAge()+"major:"+this.getMajor());}
}

Graduate类

package com.kjxy.homework;public class Graduate extends Student{private  String degree;public Graduate(String name, int age, String degree) {super(name, age);this.degree = degree;}public String getDegree() {return degree;}public void setDegree(String degree) {this.degree = degree;}@Overridepublic void info() {super.info();System.out.println("name:" + this.getName() + "age:" + this.getAge()+"major:"+this.getDegree());}
}

主类

package com.kjxy.homework;public class Test {public static void main(String[] args) {UnderGraduate u = new UnderGraduate("哈哈",20,"本科");u.info();Graduate g = new Graduate("嘻嘻",19,"硕士");g.info();}
}

21.访问权限控制符_API_Object_转型

示例代码

package com.kjxy.project;public class A {private int a;int b;protected  int c;public int d;public void fun(){a=5;b=5;c=5;d=5;}
}

package com.kjxy.project;public class Test {public static void main(String[] args) {A a = new A();//同一个包下无法访问privatea.b =1;a.c =2;a.d =3;}
}

发现bcd都行,但是a就是不行

发现只能访问c,d，不能访问a，b

package com.kjxy.project2;import com.kjxy.project.A;public class B  extends A {public void fun(){//不同包下子类无法访问private和default内容this.c =1 ;this.d =2;}}

package com.kjxy.project2;public class Test {public static void main(String[] args) {//无法访问private,default,protectedB b = new B();}
}

22.API（Application Programming Interface）

23.Object类

例如调用api接口中的object


package com.kjxy.oobe;public class Test {public static void main(String[] args) {Animals a = new Animals();a.}
}

24.Object类常用方法

直接输出对象

package com.kjxy.oobe;public class Test {public static void main(String[] args) {Animals a = new Animals();System.out.println(a);}
}

发现输出了包名加hash地址

在java当中的api文档中

发现结果还是一样的

package com.kjxy.oobe;
import java.util.Date;
public class Test {public static void main(String[] args) {Animals a = new Animals();System.out.println(a);System.out.println(a.toString());String s = new String("hello");System.out.println(s);Date date = new Date();System.out.println(date);}}

输出时间

能不能判断这两个是一样的呢，结果发现这两个是不一样的，因为他们两个对象的地址不一样，所以输出的结果也是不一样的

package com.kjxy.oobe;public class Test2 {public static void main(String[] args) {Animals a1 = new Animals();a1.setName("小黄");a1.setAge(1);Animals a2 = new Animals();a2.setName("小黄");a2.setAge(1);System.out.println(a1 == a2);}
}

System.out.println(a1 == a2);
System.out.println(a1.equals(a2));

发现结果还是错误的

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2));

发现返回值类型为true

发现返回值为false

System.out.println(s1 == s2);

25.对象转型

拓扑图理解

Person类

package com.kjxy.cc;public class Person {private String name;private  int age ;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;}
}

Student类

package com.kjxy.cc;public class Student extends Person{private String school;public String getSchool() {return school;}public void setSchool(String school) {this.school = school;}
}

Test类

package com.kjxy.cc;public class Test {public static void main(String[] args) {//父类引用指向子类对象//向上转型Person p = new Student();//向下转型Student s =(Student) p;s.}
}

然后的拓扑图

如下图

简单的通过几个方法进行示例

Person类

package com.kjxy.casting;public class Person {public void speak(){System.out.println("1'am a person");}
}

Student类

package com.kjxy.casting;public class Student extends  Person{@Overridepublic void speak() {System.out.println("1'am a student");}
}

主函数类

package com.kjxy.casting;public class Test {public static void main(String[] args) {//父类引用指向子类对象，向上转型Person p =new Person();p.speak();}
}

发现运行结果

26.多态_abstract_接口_interface

一些大纲

27.多态

一些基本的概念

场景，人在动物园抓狗，抓猫，抓老鼠

package com.kjxy.casting1;public class Dog {public void  shout(){System.out.println("旺旺旺");}
}

package com.kjxy.casting1;public class Mouse {public void shout() {System.out.println("叽叽叽");}
}

package com.kjxy.casting1;public class Cat {public  void shout(){System.out.println("喵喵喵");}
}

package com.kjxy.casting1;public class Perosn {public void catchDog(Dog dog){dog.shout();}public void catchCat(Cat cat){cat.shout();}public void catchMouse(Mouse mouse){mouse.shout();}
}

package com.kjxy.casting1;public class Test {public static void main(String[] args) {Perosn p = new Perosn();Dog d = new Dog();p.catchDog(d);Cat c =new Cat();p.catchCat(c);Mouse m = new Mouse();p.catchMouse(m);}
}

看起来就很乱了，猫狗鼠啥的，这一看就很乱这个项目结构，所以我们能不能改变一些项目结构让他变得简单一点呢

然后我们来实现代码重载

package com.kjxy.casting1;public class Dog extends Animal{public void  shout(){System.out.println("旺旺旺");}
}

package com.kjxy.casting1;public class Mouse extends Animal{public void shout() {System.out.println("叽叽叽");}
}

package com.kjxy.casting1;public class Cat extends Animal{public  void shout(){System.out.println("喵喵喵");}
}

package com.kjxy.casting1;public class Perosn {public void catchAnimal(Animal animal){animal.shout();}
}

package com.kjxy.casting1;public class Test {public static void main(String[] args) {Perosn p = new Perosn();Dog d = new Dog();Cat c =new Cat();Mouse m = new Mouse();p.catchAnimal(d);p.catchAnimal(c);p.catchAnimal(m);}
}

场景：士兵上战场，拿着 不同的武器杀敌

package com.kjxy.casting2;public class Weapon {public void attack(){System.out.println("武器攻击");}}

package com.kjxy.casting2;public class Soldier {public void KlillEnemy(Weapon w){System.out.println("士兵上战场杀敌");w.attack();}}

package com.kjxy.casting2;public class AK47  extends Weapon{@Overridepublic void attack() {System.out.println("使用ak");}
}

package com.kjxy.casting2;public class M4A1 extends Weapon{@Overridepublic void attack() {System.out.println("使用M4A1攻击");}
}

package com.kjxy.casting2;public class Knife extends Weapon{@Overridepublic void attack() {System.out.println("使用小刀攻击");}
}

package com.kjxy.casting2;public class Test {public static void main(String[] args) {Soldier s = new Soldier();AK47 ak47 = new AK47();M4A1 m4A1 = new M4A1();Knife knife = new Knife();s.KlillEnemy(ak47);s.KlillEnemy(m4A1);s.KlillEnemy(knife);}
}

发现可以运行成功

28.abstract关键字

用abstract修饰的类叫做抽象类，用abstract修饰的方法叫做抽象方法

如果一个类中有抽象方法，那么这个类必须是抽象类

抽象类不能被实例化，只能用来被继承

抽象方法没有方法体，只有方法的声明

抽象类的子类必须重写其继承的抽象方法

package com.kjxy.casting2;public  abstract class Weapon {public abstract void attack();
}

发现抽象类不能被实例化

29.接口（interface）

接口可以看作是一个特殊的抽象类

接口不能被实例化，只能被实现（implements）

接口中的默认属性都是由“public static”修饰，方法都是由“public abstract”修饰

如果一个类实现了某个接口，那么必须要重写接口中的所有办法

接口可以帮助java中不支持多继承的情况，一个类只能继承自一个父类，但可以实现多个接口

30.类的完整声明格式

package com.kjxy.casting2;public interface Gun {public abstract void shoot();
}

package com.kjxy.casting2;public  class AK47  extends Weapon implements Gun {@Overridepublic void attack() {System.out.println("使用ak攻击");}@Overridepublic void shoot() {System.out.println("压着点弹道,有点飘");}
}

package com.kjxy.casting2;public class Test1 {public static void main(String[] args) {Gun g = new AK47();Weapon w = new AK47();w.attack();g.shoot();}
}

31.final关键字

final修饰的变量不能改变

final修饰的类不能被继承

final修饰的方法不能被重写

类似于c语言中的couner

看下面的实例

32.一些基本总结

基本上Java语法也算是学完了，除此以外也包含一些各种语言的类和库

所以学习一门语言要从两方面，一方面是语法，一方法是类库

http://www.xdnf.cn/news/13497.html

相关文章：

  • leetcode题解450：删除BST中的结点！调整二叉树的结构最难！
  • ​​绿色PCB通关密码：猎板无铅焊料+水性油墨的RoHS合规实践​​
  • SpringBoot基于RabbitMQ实现异步请求处理
  • CentOS7下的Flink 集群部署
  • 【LLM】深入解析MCP的三种传输方式实现
  • 《C++ 继承》
  • 2024年12月6级第一套
  • 【HarmonyOS 5.0】开发实战：从UI到Native全解析
  • 鸿蒙多语言开发实战：3 步实现中英文动态切换（无需重启 App）附完整代码 + 避坑指南
  • CentOS7下的集群化部署
  • 电子接口与微控制器核心知识：串口、并口、USB、UART、RS232/RS485、ESP32与STM32详解
  • 零基础学前端-传统前端开发（第二期-HTML介绍与应用）（XSS防御）
  • C# StringBuilder代码中预分配容量的作用
  • 企业中使用 MCP Server 实现业务打通
  • （二）TensorRT-LLM | 模型导出（v0.20.0rc3）
  • 第一讲:认识C++程序
  • 《网络世界的“隐形窥探者”：深度剖析网络监听》
  • 系统设计 --- MongoDB亿级数据查询优化策略
  • MMaDA: Multimodal Large Diffusion Language Models
  • Vue3实现键盘字母筛选功能
  • Java 中高级开发岗技能与面试要点梳理
  • LLM基础6_在未标记数据上进行预训练
  • HTML盒子模型
  • 1.一起学习仓颉-编译环境，ide，输出hello，world
  • GitLab Web 界面创建分支后pathspec ... did not match any file(s)
  • MNIST数据集上朴素贝叶斯分类器（MATLAB）
  • 扁平表＋递归拼树思想
  • cf2117E
  • 【Pandas】pandas DataFrame interpolate
  • echarts 数据大屏（无UI设计 极简洁版）