这篇博客介绍了面向对象编程的核心概念，包括类的定义、对象的创建、构造方法的作用、重载的概念、this关键字的应用、静态成员的特性以及封装、继承和多态的基本原理。通过实例展示了如何在Java中实现这些概念，强调了它们在实际编程中的重要性。
一 . 类，对象
思想：
万物皆对象，把项目中的东西看成对象并抽象出他们的类。
类:
类是对象的高度抽象。相同事务共同特征的描述，例如 狗是动物类，每个人属于人类
格式：
public class 类名{
// 1. 成员变量（代表属性，一般是名词）
String name;
// 2. 构造器
// 3. 成员方法（代表行为，一般是动词）
public void run(){
System.out.print("动物可以跑");
}
// 4. 代码块
// 5. 内部类
}
定义类的注意事项：
- 类名首字母建议大写，有意义，满足驼峰，不要用关键字，合法的标志符
- 一个Java文件可以定义多个类，但是只能有一个类是public 修饰的，而且public修饰的类名和文件名必须一模一样
对象：
对象是类中的具体实例。二哈是对象，你也是对象。
在Java 中必须先定义一个类 class ，才能创建对象 new
格式：
- 类名 对象名 = new 构造器( );
Animal dog = new Animal();
new一个对象后在内存：堆中存放实例对象，栈中存放引用对象的地址，
栈中对象为：引用对象
堆中对象为：实例对象
堆 ：一开始不需要明确多大，要一个首地址（第一次存放的地址）
栈：想象成小数组 数据类型一致，基本数据类型存放，每格存一个。开空间之前要明确要开多大
没有在构造方法中初始化字段时，引用类型的字段默认是
null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false：
二 . 构造方法
作用：初始化一个类的对象，并返回这个对象的地址。
分类：
-
无参构造器
public DemoClass() { System.out.println("无参构造器被调用了"); }默认会自动构建，但是当写了有参构造器则不在自动构建，则需要自己写个无参构造器
-
有参构造器
public DemoClass(int age,String name) { this.age = age; this.name = name; System.out.println("有参构造器被调用了" + name + age); }this 指向当前对象，谁在用的时候就指向谁。
public static void main(String[] args) { DemoClass demo = new DemoClass(); // 此时无参构造器被调用了 DemoClass demo1 = new DemoClass(18,"刘芫"); // 此时有参构造器被调用了 }
三 . 重载
- 方法里的参数个数，数据类型，顺序不一样，则会匹配不同的方法
public class DemoClass {
public void work(int age) {
this.age = age;
System.out.println("第一个方法被调用了" + name);
}
public void work(int age,String name) {
this.age = age;
this.name = name;
System.out.println("第二个方法被调用了" + age + name);
}
public void work(String name,int age) {
this.name = name;
this.age = age;
System.out.println("第三个方法被调用了" + age + name);
}
public static void main(String[] args) {
DemoClass demo1 = new DemoClass(18); // 第一个方法被调用了
DemoClass demo2 = new DemoClass(18,"刘芫"); // 第二个方法被调用了
DemoClass demo3 = new DemoClass("刘芫"，18,); // 第三个方法被调用了
}
}
注意：小的数据类型可以匹配到大的数据类型参数方法，反过来则不行
四 . this
作用：指向当前对象，代表当前对象的地址，可以访问当前对象的成员变量和方法
- 一般用在有参构造器 和 方法中
// 有参构造器
public DemoClass(int age,String name) {
this.age = age;
this.name = name;
}
public static void main(String[] args) {
DemoClass demo1 = new DemoClass(18,"张三"); // 此时this指向的时demo1
DemoClass demo2 = new DemoClass(25,"李四"); // 此时this指向的时demo2
}
// 方法
public class Demo {
String name;
public void goWith(String name) {
System.out.println(this.name + "和" + name + "赛跑");
}
public static void main(String[] args) {
Demo demo1 = new Demo();
demo1.name = "张三"; // this 指向现在的name
demo1.goWith("李四"); // 输出： 张三和李四赛跑
}
}
五 . static（静态）
-
static 用在 ：属性 和 方法上
-
属性要是前面加上static修饰符，则这个属性 公用且永远唯一
public class DemoClass() {
static String name; // (公用,且永远唯一)
int age;
}
public static void main(String[] args) {
DemoClass demo1 = new DemoClass();
DemoClass demo2 = new DemoClass();
demo2.name = "张三";
demo2.age = "30";
// 即使demo1对象的name没有赋值，但是demo2对象给name赋值了，所以也改变l静态属性的值。
System.out.println(demo1.name + "," + demo2.age); // 输出： 张三,0
}
- 方法前面加上static修饰符，则此方法称为公用的方法，静态（公用）属性和方法 属于类，非静态（成员）属性和方法 属于对象。
注意：
- 静态方法只能访问静态的成员（属性和方法），不可以直接访问实例成员（属性和方法）。
- 实例方法可以访问静态的成员（属性和方法），也可以访问实例成员（属性和方法）。
- 静态方法中是不可以出现this关键字的
- 静态代码块， 会在构造器之前，优先执行
static {
System.out.println("我会优先执行");
}
public DemoClass() {
System.out.println("我会比静态代码块后执行");
}
六 . 封装（面对对象的三大特征之一）
-
封装的原则： 对象代表什么，就得封装对应的数据，并提供数据对应的行为。
-
如何封装更好：
-
一般建议对成员变量使用private(私有、隐藏)关键字修饰进（private修饰的成员只能在当前类中访问）
-
为每个成员变量提供配套public修饰的的getter、setter方法暴露其取值和赋值
/** *菜单实体类 每个行存放一个对象 *@author 刘芫 *@since jdk1.8 *@version 5.0 */ public class MenusEntity { // 成员属性私有化 private int menuId; private String foodName; private int price; private int goodNums; // 无参构造器 public MenusEntity() { } // 有参构造器 public MenusEntity(int menuId,String foodName,int price,int goodNums) { this.menuId = menuId; this.foodName = foodName; this.price = price; this.goodNums = goodNums; } // getter 和 setter public int getMenuId() {return menuId;} public void setMenuId(int menuId) {this.menuId = menuId;} public String getFoodName() {return foodName;} public void setFoodName(String foodName) {this.foodName = foodName;} public int getPrice() {return price;} public void setPrice(int price) {this.price = price;} public int getGoodNums() {return goodNums;} public void setGoodNums(int goodNums) {this.goodNums = goodNums;} }属性封装 方法封装 包封装 权限封装
-
七 . 继承（面对对象的三大特征之二）
- 定义：Java中提供一个关键字extends，用此关键字可以一个类和另一个类建立起父子关系。
Student称为子类（派生类），People称为父类(基类 或超类)。
- 作用：当子类继承父类后，就可以直接使用父类公共的属性和方法。
-
特点：
-
子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
-
子类不可以继承父类的私有属性
-
Java是单继承模式：一个类只能继承一个直接父类。
-
Java不支持多继承、但是支持多层继承。
-
Java中所有的类都是Object类的子类。
-
-
优点：减少代码量，方便修改代码
注意：
- 优先构造父类，再构造子类
- 子类不可以继承父类的私有属性
- 子类不可继承父类的构造方法
super
/**
*动物类
*/
public abstract class Animals { // 抽象类
public String name;
public Animals(String name) {
this.name = name;
}
public abstract void run(); // 方法原型
}
/**
*狗类
*/
public class Dog extends Animals {
public String hair;
public Dog(String name){
super(name); // 访问父类构造器
}
public void lookHose(){
System.out.println("子类独写的方法：独有的看家功能");
}
public void run(){
System.out.println("子类重写父类的方法：用四只腿跑");
}
}
八 . 多态 （面对对象的三大特征之二）
- 多态的前提：
- 存在继承关系
- 方法重载
- 子类重写父类方法 子类和父类写了同样的方式时 默认调用的时子类中的方法
1. abstract 抽象
public abstract class Animals { // 抽象类
public abstract void run(); // 方法原型，后面的继承它的子类一定要写这个方法
}
抽象类无法实例化，抽象类只是用来约束子类去实现
子类继承父类后重写 父类中对应的方法
2. 向上转型
多态向上转型的本质：父类的引用指向了子类的对象
向上转型就是父类的引用指向子类的实例。
当父类的引用指向子类对象的时候，父类的引用只可以访问子类继承父类的那部分属性和方法以及子类重写父类的方法
Pet pt = new Dog("大黄");
/**
*动物类
*/
public abstract class Animals { // 抽象类
public String name;
public Animals(String name) {
this.name = name;
}
public abstract void run(); // 方法原型
}
/**
*狗类
*/
public class Dog extends Animals {
public String hair;
public Dog(String name){
super(name);
}
public void lookHose(){
System.out.println("子类独写的方法："+ name +"独有的看家功能");
}
public void run(){
System.out.println("子类重写父类的方法：用四只腿跑");
}
}
/**
*测试类
*/
public class Test02 {
public void test(Animals 对象){ // 向上转型
对象.run(); // 子类重写父类的方法
// an.lookHose();// 子类独有的方法 报错
// System.out.println(an.hair); // 子类独有的属性报错
}
public static void main(String[] args){
Test02 ts = new Test02();
Dog 对象 = new Dog("拉布拉多");
ts.test(对象);
}
}
3. 向下转型
Dog dog = (Dog)pt;
九. 权限修饰符
private：私有的，只有类自己能调用
默认 friendly ： 包权限 同一个包才能使用
protected：受保护的
public ： 公开的
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
