本文详细介绍了面向对象编程（OOP）的基本概念，包括类与对象、封装、继承和多态。通过实例展示了如何定义和调用方法、创建与初始化对象，以及深入探讨了类的构造器、属性的封装、继承机制、多态的实现。此外，还涵盖了静态与非静态方法、异常处理、类型转换、内部类和接口等多个方面，旨在全面理解OOP的精髓。
什么是面向对象(OOP)
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。
-
抽象
-
三大特性
- 封装
- 继承
- 多态
-
从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
-
从代码运行角度考虑是先有类后有对象。类是对象的模板。
回顾方法及加深
-
方法的定义
- 修饰符
- 返回类型
public String hello(){ return "chenshuang"; } public void SayHello(){ return; }-
break：跳出switch，结束循环；return：结束方法。返回一个结果。
-
方法名：注意规范就好， 见名知意
-
参数列表：（参数类型、参数名）……
-
异常抛出：
public void readFile(String file) throws IOException{ }
-
方法的调用
- 静态方法及调用
public class Demo02 { public static void main(String[] args) { int sum=0; sum = add(10,20);//调用静态方法 System.out.println(sum); } public static int add(int a,int b){ return (a+b); } }-
非静态方法及调用
public class Demo03 { public static void main(String[] args) { Demo02.add(2,3);//调用静态类 //实例化这个类 new //对象类型 对象名 = 对象值； Demo03 demo03 = new Demo03(); demo03.say();//调用非静态类 } public String say(){ return "java"; } } -
形式参数和实际参数
public class Demo04 { public static void main(String[] args) { Demo04 demo04 = new Demo04(); int result = 0; //实际参数 result = demo04.sub(8,6); System.out.println(result); } //形式参数 int sub(int a,int b){ return (a-b); } }-
值传递
public class Demo05 { public static void main(String[] args) { //值传递 int a = 1; System.out.println(a);// 1 Demo05.change(a);//调用 System.out.println(a);// 1 } public static void change(int a){ a = 10; } }-
引用传递
public class Demo06 { //引用传递 ： 对象，本质还是值传递 public static void main(String[] args) { Person person = new Person(); System.out.println(person.name); // chenshuang Demo06.change(person); System.out.println(person.name);// 陈爽 } public static void change(Person person){ person.name = "陈爽"; } } // 定义一个 Person类，有一个属性：name class Person{ String name = "chenshuang"; } //执行结果 chenshuang 陈爽
-
-
类与对象的关系
类:是一种抽象的数据类型，他是对某一事物整体描述/定义，但是并不能代表具体的一个事物
- 动物、植物、手机……
对象是抽象概念的具体实例
张三是人的具体实例，狗是动物的具体实例…………
创建与初始化对象
使用new关键词创建对象
创建的同时，除了分配内存空间以外，还给创建好的对象进行默认初始化，以及 对类中构造器的调用
例：
//学生类
public class Student {
//属性：
String name;
int age;
//方法：
public void study(){
System.out.println(this.age+"的"+this.name+"在学习！");
}
}
//测试
public class Application {
public static void main(String[] args) {
//类的实例化
Student chenshuang = new Student();
Student dafei = new Student();
chenshuang.name="陈爽";
chenshuang.age=23;
chenshuang.study();
dafei.name="李腾飞";
dafei.age=24;
dafei.study();
}
}
//执行结果
23的陈爽在学习！
24的李腾飞在学习！
类中的构造器也成为构造方法，同时进行创建对象的时候必须调用的。并且构造器有以下俩特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能是void
构造器：
1、和类名相同
2、没有返回值
作用：
1、new本质在调用构造方法
2、初始化对象的值
注意点：
1、定义有参构造之后，如果想使用无参构造，显示的定义的一个无参的构造。
快捷键： Alt + Insert
例：
public class Person {
//一个类即使什么都不写，也会存在一个方法
//显示的定义构造器
String name;
int age;
//alt + insert 快捷键
//无参构造
//1、使用new关键字，本质上实在调用构造器
//2、用来初始化值
public Person() {
}
//有参构造：一旦定义了有参构造，无参就必须显示定义
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
/*
public static void main(String[] args) {
//new 实例化一个对象
Person cs = new Person();
Person chen = new Person("cs",23);
}
*/
小结
1、类与对象
类是一个模板：抽象，对象是一个具体的实例
2、方法
定义、调用
3、对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的： 栈 ----> 堆
4、属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char ： u0000
Boolean： false
引用： null
修饰符 属性类型 属性名 = 属性值！
5、对象的创建和使用
- 必须使用new 关键字创造对象，构造器 Person chenshuang = new Person()；
- 对象的属性 chenshuang.name;
- 对象的方法 chenshuang.study();
6、类
静态的属性 属性
动态的方法 方法
7、封装、继承、多态
封装
-
程序追求**“高内聚，低耦合”**
-
禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，称为信息隐藏。
-
属性私有，get/set
例
package oop.demo02;
//类 private ：私有
public class Student {
//属性私有
private String name; //名字
private int age; //年龄
private int grade; //分数
//提供可以操作这个属性的方法
//提供一些public 的get、set方法
//get获得这个方法
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(java.lang.String name) {
this.name = name;
}
// 快捷键： Alt + Insert
public int getAge() {
return age;
}
//可以加判断
public void setAge(int age) {
if (age>120||age<=0){
System.out.println("不合法，重新输入！");
}else {
this.age = age;
}
}
}
/*
public class Application {
public static void main(String[] args) {
Student cs = new Student();
cs.setName("陈爽");
System.out.println(cs.getName());
cs.setAge(123);
System.out.println(cs.getAge());
}
}
*/
继承
-
JAVA中类只有单继承，没有多继承【一个儿子只有一个父亲，一个父亲可以有多个儿子】
-
继承是类和类之间的一种关系，除此之外，类和类之间还有以来、组合、聚合等关系
-
被final修饰的类不能在被继承。断子绝孙！
-
public final class Person { }
-
-
extands的意思是扩展，子类是父类的扩展
-
父类
//在Java中，所有的类都直接或者间接的继承Object //Person 人： 父亲 public class Person { int money = 10_0000_0000; public void say(){ System.out.println("说话！"); } //private修饰 不可以继承 private int add(int a,int b){ return(a+b); } } -
子类 extends
//学生 is 人 ：子类、派生类 //子类继承了父类，就会拥有父类的全部方法！ public class Student extends Person { }
-
super
super注意点：
- super调用父类的构造方法，必须是构造方法的第一个。
- super必须只能出现在子类的方法或者构造方法中！
- super 和 this 不能同时调用构造方法
对比this：
- 代表对象不同
- this：本身调用这个对象
- super：代表父类对象的应用
- 前提
- this：没有继承也可以使用
- super：只能在继承的条件下才可以使用
- 构造方法
- this（）；本类 的构造
- super（）；父类的构造
父类
public class Person {
protected int age = 21;
int sub(int a, int b){
return (a-b);
}
}
子类
public class Student extends Person {
int age = 23;
public int sub(int a, int b){
return (a-b);
}
public void test(int age) {
System.out.println(age);
System.out.println("本类调用："+this.age);
System.out.println("父类调用："+super.age);
}
public void test1() {
System.out.println(sub(4, 1));
System.out.println("本类调用："+this.sub(5, 3));
System.out.println("父类调用："+super.sub(8, 4));
}
}
重写
需要有继承关系，子类重写父类的方法！
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小；
- public > Protected > Default > private
- 抛出的异常：范围，可以被缩小，但是不能被扩大；
- ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致；方法体不同！
为什么要重写？
-
父类的功能，子类不一定需要；方法体不同！
重写快捷键：Alt + Insert；
静态的方法和非静态的区别很大
-
静态方法：方法的调用只和左边定义的数据有关。
A a = new A(); a.test(); A B = new A(); b.test(); -
非静态方法：重写
多态
多态：及同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类、有关系的类等）
例：
//父类
public class Person {
public void say(){
System.out.println("父类的方法say（）");
}
}
//子类
public class Student extends Person {
@Override
public void say() {
System.out.println("子类重写say（）方法");
}
public void eat(){
System.out.println("子类独有方法eat（）");
}
}
//测试类
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型不确定。
//student 能调用的方法都是自己的、或者继承父类的
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法！
Person s2 = new Student(); //父类的引用指向子类
Object s3 = new Student(); //祖宗类的引用指向子类
//对象能执行哪个方法主要看对象左边的类型。和右边关系不大！
s1.say();
s2.say();
s1.eat();
((Student)s2).eat();//强制转换类型，把父类转换成子类
}
}
//执行结果
子类重写say（）方法
子类重写say（）方法
子类独有方法eat（）
子类独有方法eat（）
多态注意事项：
- 多态是方法的多态，属性没有多态。
- 父类和子类，有联系 类型转换异常！ ClassCastException!
- 存在条件：1、继承关系 2、方法需要重写。 3、父类引用指向子类对象！【 Father f1 = new Son(); 】
- 不能被重写：
- static 方法，属于类，它不属于实例
- final 常量；
- private 方法；
- 不能被重写：
instanceof和类型转换
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
例：
package oop.demo05;
public class Application {
public static void main(String[] args) {
// instanceof 用来测试左边的对象是不是右边类的实例
// 类的关系：
// Object > String
// Object > Person > Teacher
// Object > Person > Student
Object object= new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false
System.out.println(object instanceof Teacher);//false
System.out.println("=================================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String); 编译出错
System.out.println("=================================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
// System.out.println(student instanceof String);编译出错
// System.out.println(student instanceof Teacher);编译出错
}
}
//执行结果
true
true
true
false
false
=================================
true
true
true
false
=================================
true
true
true
类型转换
父类
public class Person {
public void say(){
System.out.println("Person中say（）方法···");
}
}
子类Teacher
public class Teacher extends Person {
public void study(){
System.out.println("子类Teacher中study（）方法！");
}
}
子类Student
public class Student extends Person {
public void play(){
System.out.println("Student中play（）方法！");
}
}
测试类
public class Application {
public static void main(String[] args) {
Person p1 = new Teacher();
// p1将这个对象转换成Teacher类型，就可以使用Teacher类型的方法了！
Teacher t1 = (Teacher) p1;//强制转换 父类转子类；
t1.study();
((Teacher)p1).study();
//子类转父类，会丢失一些方法。
Student student = new Student();
student.play();
Person person = student;
}
}
类型转化
- 父类引用指向子类对象
- 子类 -------> 父类 ，向上转型，可能会丢失方法；
- 父类 -------> 子类，向下转型，需要强制转换。
- ((Teacher)p1).study();
- Teacher t1 = (Teacher) p1;
t1.study();
- 方便方法的调用，减少重复的代码！简洁！
Static关键字详解
静态变量
public class Student {
private static double score = 100; //静态变量
private int age = 23; //非静态变量
public void play(){
}
public static void eat() {
}//静态方法
public static void main(String[] args) {
Student s1 = new Student();
//调用
System.out.println(s1.age);
System.out.println(s1.score);
System.out.println(Student.score);
eat();
s1.play();
}
}
代码块
public class Person {
// 2、
{
System.out.println("匿名代码块");
}
// 1、 只执行一次！！
static {
System.out.println("静态代码块");
}
// 3、
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("===============");
Person person1 = new Person();
}
}
静态导包
import java.lang.Math;//导包
import static java.lang.Math.random;//静态导包
import static java.lang.Math.PI;//静态导包
public class Text {
public static void main(String[] args) {
System.out.println(Math.random());//随机数方法
System.out.println(PI);
}
}
抽象类
抽象：抽象是将共性抽离出来，产生抽象性概念非具体。
- 抽象类不能new出来，只能靠子类实现
- 抽象方法必须在抽象类中
- 抽象类中可以写普通的方法
- ：抽象的抽象！
父类（抽象类）
//abstract 抽象类
public abstract class Abstract {
//约束，有人帮我们实现
//abstract，抽象方法：只有方法名字，没有方法体；
public abstract void doSomething();
}
子类
- 继承抽象类的子类，都必须实现父类（抽象类）的所有方法【重写】
- 除非子类也是抽象类。则让子类的子类去实现即可。
public class A extends Abstract {
@Override
public void doSomething() {
}
}
//或者子类也是抽象类
public abstract class A extends Abstract {
}
抽象类存在构造器
抽象类存在构造方法，只是不能直接对该抽象类进行实例化。
在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。
即使你没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，没有的话你的子类将无法编译，因为在任何构造函数中的第一条语句隐式调用super（）。
抽象类
public abstract class Base{
int a=7;
public Base(){
a=8;
}
public Base(int i){
a=i;
}
}
子类
public class Demo01 extends Base {
public Demo01(){
super();
}
public Demo01(int i){
super(i);
}
public static void main(String[] args) {
Demo01 demo=new Demo01();
System.out.println(demo.a);
Demo01 demo1=new Demo01(9);
System.out.println(demo1.a);
}
}
//执行结果
8
9
接口
接口（英文：Interface）：是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
可以理解为接口是一系列方法和特征的集合。
public interface jiekou {
}
- 接口无法被实例化
- 接口中没有构造方法
- 接口必须有实现类
- implements可以实现多个接口
接口
public interface jiekou {
//接口中定义的常量--静态常量 public static final
public static final int age = 10; //在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
//接口中所有的定义的方法都是抽象的 publi abstract
public abstract void add();
void delete();
void update();
void query();
}
接口1
public interface jiekou1 {
void sub();
}
实现类
- 一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。（实现接口的类，必须重写接口中的所有方法）
- 多继承。可以利用接口实现多继承
public class demo implements jiekou,jiekou1 {
@Override
public void add() {
}
@Override
public void delete() {
}
@Override
public void update() {
}
@Override
public void query() {
}
@Override
public void sub() {
}
}
内部类
成员内部类
public class Outer {
//成员内部类
public class inner{
int age = 24;
public void come(){
System.out.println("内部类come方法！");
}
}
测试类
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.inner inner = outer.new inner();
System.out.println(inner.age);
inner.come();
}
}
//执行结果
内部类come方法！
23
内部类与外部类的互相调用
public class Outer {
private int id=23;
public void go(){
System.out.println("外部类go方法！");
}
//内部类
public class inner{
int age = 24;
public void come(){
System.out.println("内部类come方法！");
}
//内部类调用外部类属性及方法
public void getOuter(){
System.out.println(id);
System.out.println(Outer.this.id);
go();
}
}
//外部类调用内部类属性及方法
public void getInner(){
inner inner = new inner();
inner.come();
System.out.println(inner.age);
}
}
静态内部类
public class Outer {
//静态内部类
public static class inner{
int age = 24;
public void come(){
System.out.println("内部类come方法！");
}
}
局部内部类
public class test {
//局部内部类
public void method(){
class Inner{
public void in(){
System.out.println("局部内部类in方法");
}
}
}
}
匿名内部类
public class test {
public static void main(String[] args) {
//没有名字初始化类，不用把实例保存到变量中去
new niming().no();
new jiekou() {
@Override
public void name() {
}
};
}
}
class niming{
public void no(){
System.out.println("匿名类的no方法！");
}
}
interface jiekou{
void name();
}
6834
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
