本文深入探讨了面向对象编程的核心概念，包括静态和非静态方法的区别、如何调用本类方法、类与对象的关系、构造器的使用以及内存分析。此外，还详细讲解了封装、继承、多态等特性，以及`instanceof`、`static`关键字的应用，并举例说明了抽象类的使用场景。
面向对象编程
属性加方法就是一个类oop
面向对象的本质：以类的方式组织代码，以对象的形式组织（封装）数据
三大特性
封装
继承
多态
静态方法
修饰符加static
在别的类中使用时
Demo01.say();
非静态方法
不加static
//非静态方法
//1.实例化一个类 new
new Demo01().say();//创建了Demo01，调用了它的say（）方法
//常用
//对象类型 对象名 = 对象值
Demo01 demo01 = new Demo01();
demo01.say();
package kuang.Oop;
public class Demo02 {
public static void main(String[] args) {
//非静态方法
//1.实例化一个类 new
new Demo01().say();//创建了Demo01，调用了它的say（）方法
//常用
//对象类型 对象名 = 对象值
Demo01 demo01 = new Demo01();
demo01.say();
}
public int a(){
System.out.println("I am Jiateng.");
return 0;
}
public static void b(){//static是和类一起加载的，在这里不能调用没有出现的方法
a();
}
}
两种方法调用本类的方法
package kuang.Oop;
public class Demo02 {
public static void main(String[] args) {
//1.非静态
Demo02 demo02 = new Demo02();
demo02.a();
System.out.println("================");
//2.静态调用
Demo02.b();//或者b（）
System.out.println("================");
b();
}
public int a(){
System.out.println("I am Jiateng.");
return 0;
}
public static int b(){
System.out.println("I am Jiateng.");
return 0;
}
}
类与对象的关系
一个项目应该只有一个main方法
this代表当前这个类
package kuang.Oop.DEmo02;//主程序
public class Application {//一个程序应该只有一个main方法
public static void main(String[] args) {
//类是抽象的，需要实例化，用new。
// 类实例化后会返回一个自己的对象。
//xiaoming对象就是Studen类的具体实例
Studen xiaohong = new Studen();
Studen xiaoming = new Studen();
xiaohong.name="小红";
xiaohong.age=5;
xiaoming.name="小明";
xiaoming.age=4;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
package kuang.Oop.DEmo02;
//学生类 抽象
public class Studen {
//属性
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");//this只代这个类
}
}
创建初始化对象
-
使用new关键字穿件对象
使用new关键字出案件的时候，除了分配内存空间外，还会给创建好的对象进行默认初始化
以及对类中构造器的调用。
-
构造器必须掌握
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
构造器
构造器=构造方法
构造方法不能被继承，但可以用super调用
不能用private修饰
一个类什么都不写他也会存在一个构造器
两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能void
使用new关键字本身是在调用构造器
构造器用来初始化值
有参构造：一旦定义了有参构造，无参就必须显示定义
快捷键：Fn+alt+insert
package kuang.Oop.DEmo02;
public class Application {//一个程序应该只有一个main方法
public static void main(String[] args) {
//new实例化一个对象
Studen studen = new Studen("waj");
System.out.println(studen.name);
studen.name="o";
System.out.println(studen.name);
}
}
/*类是抽象的，需要实例化，用new。
// 类实例化后会返回一个自己的对象。
//xiaoming对象就是Studen类的具体实例
Studen xiaohong = new Studen();
Studen xiaoming = new Studen();
xiaohong.name="小红";
xiaohong.age=5;
xiaoming.name="小明";
xiaoming.age=4;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
*/
package kuang.Oop.DEmo02;
//学生类 抽象
public class Studen {
String name;
//显示定义的构造器
//一个类什么也不写也会存在一个构造器
public Studen(){//使用new关键字本身是在调用构造器
//构造器用来初始化值
this.name="jiateng";
}
public Studen(String name){
this.name=name;
}
}
/*属性
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");//this只代这个类
*/
创建对象内存分析
类是一个模板
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WbDhbMOS-1635067850005)(D:\学习截图\内存分析.png)]
小结
-
类与对象
类是一个模板：抽象，对象是一个具体的实例
-
方法的定义调用
-
对象是通过引用来调用的：栈–>堆
-
属性：字段Field 成员变量
-
对象的创建和使用
- 必须使用new关键字创造对象，调用构造器
- 对象的属性 jiateng.name
- 对象的方法 jiateng.sleep（）
-
类
静态的属性 属性
动态的方法 方法
java三大特征
封装、集成、多态
封装
高内聚，低耦合：高内聚类的内部数据操作自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用
private：私有
好处：
- 提高代码的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增加
package kuang.Oop.Demo03;public class Application { public static void main(String[] args) { Student s1 = new Student(); System.out.println(s1.getName()); s1.setName("jiateng"); System.out.println(s1.getName()); s1.setAge(90); System.out.println(s1.getAge()); }}
package kuang.Oop.Demo03;import com.sun.media.jfxmediaimpl.HostUtils;//类public class Student {//public:公开 private：私有（外部无法使用） private String name;//姓名 private int age;//年龄 private char sex;//性别//因为private私有，所以提供一些public的get、set方法 //获得这个数据 /*public String getName() { return name; }*/ //给这个数据设置值 public void setName(String name) { this.name = name; } public String getName(){ return name; } public int getAge(){ return age; } public void setAge(int age){ if(age>120||age<0){ System.out.println("不合法"); } else{ this.age=age;//this-->Student } }}
继承
继承的本质是对某一批类的抽象。从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
java中只有单继承，没有多继承！（一个儿子只有一个爸爸，一个爸爸可以有多个儿子）
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用extends来表示
子类和父类之间，从意义上讲具有“is a”的关系
子类可以用父类中的所有方法
修饰符
public
private
default（默认）
protected
在java中，所有的类，都默认继承object
super
super注意点：
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或构造方法中
- super和this不能同时调用构造方法！（因为他们都必须在第一行）
VS this
代表对象不同：
this：本身调用这个对象
super:代表父类对象的引用
前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
构造方法
this（）：本类的构造
super（）：父类的构造
主程序：
package kuang.Oop.Demo04;public class Application { public static void main(String[] args) { Student student = new Student(); /*student.say();//Student继承了Person的方法 System.out.println(student.many);//Student继承了Person的many System.out.println("============="); student.text("null"); System.out.println("============="); student.texe1(); */ }}
父类：
package kuang.Oop.Demo04;public class Person {//ctrl+h public Person() { } public Person(String name){//定义有参构造时，隐化的无参构造就没了，需要定义。 System.out.println("Person的无参执行了"); } public int many=10_0000_0000;//私有的东西无法被继承 protected String name="qinjiang"; public void say(){ System.out.println("说了一句话"); } public void print(){ System.out.println("qinjiang "); }}
子类：
package kuang.Oop.Demo04;//学生 is 人 子类 派生类public class Student extends Person { public Student(){//构造器的作用 //此处有隐藏代码super（）；，如果显化，此代码为子类构造器中的第一行代码。 //this调用构造器也必须是第一行代码 super(); System.out.println("Student的无参构造器被执行了"); } String name="佳腾"; public void text(String name){//属性实验 System.out.println(name); System.out.println(this.name); System.out.println(super.name );//super与this用法相近，但是指父类中的对象 } public void print(){ System.out.println("student"); } public void texe1(){//方法实验 print(); this.print(); super.print(); }}
重写
重写都是方法的重写与属性无关
重写只和非静态方法有关，与静态方法无关。
注意点：
重写：需要有继承关系，子类重写父类的方法！
- 方法名必须相同
- 参数列表必须相同
- 修饰符只能扩大不能缩小：public>protected>default>private
- 抛出异常：范围，可以被缩小 但，不能被扩大
重写子类的方法和父类必须一致；方法体不同
为什么需要重写
父类的功能，子类不一定需要，或者不一定满足。
fn+alt+insert:override
package kuang.Oop.Demo05;//重写都是方法的重写，与属性无关public class Application { public static void main(String[] args) { A a=new A(); a.texe();//A类 B b=new A();//子类重写了父类的方法 b.texe(); }}
package kuang.Oop.Demo05;public class B { public void texe(){ System.out.println("B-->"); }}
package kuang.Oop.Demo05;//A类继承了B类public class A extends B{ public void texe(){ System.out.println("A-->"); }}
csdn
package four;//定义一个类class Animals{ String name; void shout(){ System.out.println("动物发出叫声"); }} //定义dog类继承Animal类class Cat extends Animals{ void shout(){ System.out.println("喵喵喵。。。"); } }public class Test02_Rewrite { public static void main(String[] args) { Cat cat=new Cat(); cat.shout();//调用重写后的shout()方法 }}————————————————版权声明：本文为CSDN博主「Apolar_SH」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/qq_35923287/article/details/90079309
多态
多态注意点：
- 多态是方法的多态，属性没有多态
- 父类与子类，有联系 类型转换异常ClasscastException！
- 存在条件：继承关系 方法重写 父类引用指向子类对象！Fath f1=new son（）；
方法不能被重写：
- static 方法，属于类，他不属于实例
- final 常量不可改变
- private私有
理解：
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。
**多态体现为：**父类引用变量可以指向子类对象。
*注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。*
多态案例：
package day0524; public class demo04 { public static void main(String[] args) { People p=new Stu(); p.eat(); //调用特有的方法 Stu s=(Stu)p; s.study(); //((Stu) p).study(); }}class People{ public void eat(){ System.out.println("吃饭"); }}class Stu extends People{ @Override public void eat(){ System.out.println("吃水煮肉片"); } public void study(){ System.out.println("好好学习"); }}class Teachers extends People{ @Override public void eat(){ System.out.println("吃樱桃"); } public void teach(){ System.out.println("认真授课"); }}
instanceof
转换便于使用方法
package kuang.Oop.Demo06;public class Demo01 { public static void main(String[] args) { //高 低 Person student = new Student(); ((Student)student).go();//go()是Student的方法 //student将这个对象转化为Student类型，就可以使用Student的方法了 //如果编译器报错则两者为不相干的类，结果为true则是这个类型 //false不是这个类型 System.out.println(student instanceof Teacher );//true System.out.println("=============================="); Student student1 = new Student(); student1.say(); Person person =student1;//子类转换为父类可能会丢失自己的方法。 person.eat(); }}class Person{//父类 //属性 private int a=1; void eat(){ System.out.println("吃饭"); System.out.println(a); say(); } void say(){ System.out.println("说了一句话"); }}class Student extends Person{//子类 void go(){ System.out.println("跑了一圈"); say(); } @Override void eat() { System.out.println("学生吃饭"); }}class Teacher extends Person{ @Override void eat() { System.out.println("老师吃饭"); }}
static
非静态的方法可以调用静态的方法，因为静态方法加载早。
private static int a;private int b;public static void main(String[] args) { /*Animal cat1 = new Cat();//多态 System.out.println(cat1 instanceof Cat); ( (Cat)cat1).say(); System.out.println("=========="); */ a=1; new Demo02().b=0;//非静态需要实力化对象 //2. new Demo02().eat(); //1. Demo02 demo02 = new Demo02(); demo02.eat();}public static void say(){//静态方法}public void eat(){ say();//静态加载早，可以被调用}
代码块
静态代码块（只执行一次）–>匿名代码块–>构造器
package kuang.Oop.Demo06;public class Dmo03 {//代码块 { System.out.println("匿名代码块");//第二，作用是赋初值 } static{//static只执行一次 System.out.println("静态代码块");//第一 } public Dmo03(){//第三 System.out.println( "构造器" ); } public static void main(String[] args) { new Dmo03(); }}
抽象类（约束）
- 不能new这个抽象类，只能靠子类去实现类它。约束
- 抽象类中可以写普通。
- 抽象方法必须在抽象类中方法。
package kuang.Oop.Demo07;abstract class Demo01 {//抽象类 abstract //抽象方法 只有方法名字，没有方法实现 //需要有人帮我们实现 //可以实现一些neiron public abstract void say();}public class Demo02 extends Demo01 {//继承后，子类必须重写父类的抽象类,除非子类也是抽象类 @Override public void say() { }}
扫一扫
2393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
