Java面向对象编程（OOP）

1.初识面向对象

1.1 面向过程

• 步骤清晰简单，第一步做什么，第二步做什么…
• 面对过程适合处理一下简单问题

1.2 面向对象思维

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些类，然后对这些类进行单独思考，最后，才对某个分类下的细节进行面向过程思考
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

1.3 什么是面向对象

• 本质：以类的方式组织代码，以对象的组织（封装）数据
• 抽象
• 三大特性：封装，继承，多态

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程思路去处理

比如，造房子需要建筑师，粉刷匠，搬运工（对象），这些对象各自做的事情要按照一定方法（过程）

2.方法回顾和加深

2.1 方法的定义

• 修饰符（public，static，final…）
• 返回类型
• break（结束循环，跳出switch） and return（结束方法） 的区别
• 方法名：驼峰命名
• 参数列表（参数类型 参数名）
• 异常抛出

public void readFile(String file) thorws IOException{
}
//数组下标越界
Arrayindexoutofbounds

2.2 方法的调用:(包括递归)

• 静态方法（static）

Student.say();
Arrays.fill(nums,0);

• 非静态方法

//实例化一个类 new
new Student().say();
一般是这样写
Student s = new Student();
s.say();

public class demo1{
//和类一起加载的
public static void a(){
b();//X，不能调用还没有存在的函数
//正确调用函数b（）,应该先实例化对象
demo1 d = new demo1();
d.b();
}
//类实例化之后才存在
public void b(){
}
}

• 形参和实参

public class demo3{
public static void main(String[] args){
//实际参数和形式参数的类型要对应
int add = demo3.add(1,2)//实参
}
public static int add(int a,int b){//形参
return a+b;
}
}

• 值传递和引用传递

Java都是值传递

//值传递
public class demo4{
public static void main(String[] args){
int a=1;
System.out.println(a);//a=1
demo4.change(a);
System.out.println(a);//a=1
}
public static void change(int a){
a=10;
}
}

引用传递：传递一个对象，本质还是值传递

//引用传递：对象，本质还是值传递
public class demo5{
public static void main(String[] args){
Person perosn = new Person();
System.out.println(person.name);//null
change(person);
System.out.println(person);//lhp
}
public void change(Person person){
//person是一个对象，指向---->Person类，这是一个具体的人，可以改变属性
peoson.name="lhp";
}
}
//一个Java文件里面只允许有一个public类，但是可以有多个类
//定义一个Person类，有一个属性：name
class Person{
String name;
}

• this关键字：代表当前这个类，如果写了static，则不能使用this

3.对象的创建分析

• 使用new创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创造好的对象进行默认初始化，以及对类中构造器调用
• 类中的构造器也称构造方法，是进行创建对象的时候必须要调用的，并且构造有两个特点：

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

3.1构造器

1. 一个类即使什么都不写，它也会存在一个方法（无参构造）
2. 无参构造可以初始化一些信息

package com.operator.test02;
public class Person {
String name;
//使用new关键字，必须要有构造器
//new关键字的本质是调用构造器
//无参构造(显示定义)
public Person(){
this.name="lhp";
}
//有参构造
//一旦有了有参构造，无参构造就必须显示定义！！！
//如果定义了有参构造，再去调用无参构造，就必须要显示定义无参构造！！
public Person(String name){
this.name=name;
}
}
//Alt + insert
----> 点击constructor，自动生成构造器

package com.operator.test02;
//一个项目只允许有一个main方法，用于测试
public class Application {
public static void main(String[] args) {
//如果定义了有参构造，再去调用无参构造，就必须要显示定义无参构造！！
Person perosn1=new Person();
Person person2=new Person("lhp");
}
}

构造器：1.构造器和类名相同。2.并且没有返回值。

作用：1.new本质在调用构造方法。1.初始化对象。

注意：1.定义有参构造之后，如果想要使用无参构造，就必须显示定义一个无参构造！！！

快捷键：**Alt + Insert **，点击constructor

• 类里面只有属性和方法

public class Student{
String name;
int age;
public void study(){
System.out.println(this.name+"student");
}
}

//一个项目只允许有一个main方法，用于测试
public class Application {
public static void main(String[] args) {
student lhp = new student();
student lrx = new student();
lhp.name="lhp";
lrx.name="lrx";
lhp.age=20;
lrx.age=23;
System.out.println(lhp.name+":"+lhp.age);
System.out.println(lrx.name+":"+lrx.age);
}
}

3.2创建对象内存分析

详见狂神说Java

&面向对象小总结

1. 类与对象：类是一个模板：抽象。对象是一个具体实例
2. 方法：定义，调用
3. 对应的引用：

引用类型： 基本类型（8个）

对象是通过引用来操作的：栈—>堆

4. 属性：字段Field，成员变量

默认初始化：

​ 数字：0 ， 0.0

​ char：u0000

​ boolean：false

​ 引用： null

修饰符 属性类型 属性名 = 属性值 ！

5. 对象的创建和使用

必须使用new关键字创建对象，构造器 Person person= new Person()

对象的属性 person.name

对象的方法 person.sleep()

6. 类：

静态属性：属性

动态方法：方法

4.面向对象三大特性

4.1 封装

• 程序设计追求“高内聚，低耦合”。高内聚：类的内部数据操作细节自己完成。低耦合：仅暴露少量的方法供外部使用
• 封装（数据的隐藏）

通常，应该禁止直接访问一个对象中的实际表示，而应该通过操作接口来访问，这称为信息隐藏

• 记住这句话：属性私有，get / set（对外的接口）

package com.operator.test02;
public class Person {
//属性私有
private String name;
private int age;
//set和get是私有类属性对外的接口
//在类往外面获得私有属性的信息
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;
}
//快捷键Alt + insert
}

package com.operator.test02;
//一个项目只允许有一个main方法，用于测试
public class Application {
public static void main(String[] args) {
Person person = new Person();
person.setAge(20);
person.setName("lhp");
System.out.println(person.getAge());
System.out.println(person.getName());
}
}

意义：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了

4.2 继承

• 本质是堆某一批类的抽象，从而实现堆现实世界更好的建模
• extends的意思是“扩展”，子类是父类的扩展
• Java中类只有单继承，没有多继承！（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）
• 私有的东西无法被继承

public class student extends Person{}//Person的单继承
public class teacher extends Person{}//Person的单继承
public class s1 extends student{}//X Person的多继承不可以用

• 继承是类和类之间的一种关系，除此之外，类和类还有依赖，组合，聚合等的关系
• 继承关系的两个类，一个为子类（派生类），一个为父类(基类）。子类继承父类使用关键字extends来表示
• 子类和父类从意义上讲应该有“is a ”的关系
• object类
• super
• 方法重写

注意：

1. 子类可以继承父类的所有public方法
2. Ctrl + H可以看继承的关系树
3. 在Java中，所有的类都默认直接或者间接继承Object类

4.2.1 super（对比this）

//父类
public class Person {
private String name;
public Person() {
this.name = "lrx";
}
public String getName() {
return name;
}
}

//子类
public class student extends Person{
String name;
public student() {
this.name="lhp";
}
public void test(){
System.out.println(this.name);// lhp
System.out.println(super.getName()); //lrx
}
}

同时，对于创建一个子类，会优先调用父类的构造器，隐藏代码，不然会报错

必须先有爸爸，才能有儿子

//在main中创建一个student对象
student stu = new student();
//在student中的无参构造有隐藏代码
public student(){
super();//隐藏代码，必须优先执行super父类的构造函数，必须在子类构造器的第一行
}

super注意点：

1. super是调用父类的构造方法，必须放在子类构造方法的第一个（父类无无参构造默认不显示）
2. super必须出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法

super和this的对比：

1. 代表的对象不同:

​ this：代表本身调用者这个对象

​ super：代表父类对象的引用

2. 使用前提：

​ this：没有继承也可以使用

​ super：只有在继承条件下才可以使用

3. 调用构造方法的区别：

​ this():调用本类的无参构造

​ super():调用父类的无参构造

4.2.2 方法重写

4.2.2.1静态方法下的重写

//父类
public class A {
public static void test(){
System.out.println("A->test");
}
}
//子类
public class B extends A {
public static void test(){
//Override:重写的意思
//快捷键 Alt + insert
@Override //注解：有功能的注解
System.out.println("B->test");
}
}
//main
//重写都是方法的重写，和属性无关
public static void main(String[] args) {
//静态方法：方法的调用只和左边，即定义的数据类型有关
B b = new B();//子类
b.test();//B->test
//父类的引用指向了子类
A a = new B();//父类
a.test();//A->test
}

4.2.2.2 非静态方法下的重写

//父类
public class A {
public void test(){
System.out.println("A->test");
}
}
//子类
public class B extends A {
public void test(){
//Override:重写的意思
//快捷键 Alt + insert
@Override //注解：有功能的注解
System.out.println("B->test");
}
}
//main
//重写都是方法的重写，和属性无关
public static void main(String[] args) {
//非静态方法才有重写
B b = new B();//子类
b.test();//B->test
//父类的引用指向了子类
A a = new B();//父类
a.test();//B->test!!!(区别上面的静态方法)
//非静态方法只打印子类的方法
}

注意：

静态的方法和非静态的方法区别很大，

• 静态方法（static）：方法调用只和左边，即定义的数据类型有关
• 非静态方法：非静态方法才有重写

4.2.2.3 总结

重写：需要有继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，但不能缩小：public > protected > default > private

父类是private的方法，子类可以是重写为public，返之则不行

4. 抛出的异常：异常的范围，可以缩小，但是不能扩大。（就好像你爸爸欠了100万，儿子继承父亲，就应该欠的更少）

Exception(大)-------------->ClassNotFoundException(小)

重写，子类的方法和父类必须一致；方法体不同

为什么需要重写？

1. 父类的功能，子类不一定满足，不一定需要！

重写快捷键：Alt + Insert

4.3 多态

• 动态编译：使类型的可扩展性增强（编译的时候才确定对象）

• 同一个方法可以根据发送对象的不同而采取多种不同的行为方式

• 一个的实际类型使确定的，但可以指向对象的引用的类型有很多（父类引用子类，有关系的类引用）

• 注意：多态是方法的多态，属性没有多态性

• instanceof（类型转换->引用类型之间的转换）

4.3.1 多态存在的条件：

1. 有继承关系
2. 子类重写父类方法（非静态方法）
3. 父类引用指向子类对象

注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 。否则有类型转换异常！（ClassCastException!）
3. 多态存在的条件：要有继承关系，方法需要重写，父类引用指向子类对象(Father f1 = new Son;)
4. 有些方法不能重写：static 方法：属于类，它不属于实例

​ final 常量

​ private 方法

4.3.2 instanceof和类型转换

• instanceof判断两个类是否有关系

public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Student
/*
System.out.println(X instanceof Y);
instanceof作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型
如果编译通过，说明存在父子关系，如果编译不通过，则不存在父子关系
左边是对象X，右边是类Y；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
*/
//要是没有关系，instanceof就会报错
Object object = new Student();//这里的object是Student类，但指向Object
System.out.println(object instanceof Student);//true子类创建的对象
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Teacher);//false
//如果Object object = new Teacher();则object instanceof Teacher为true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false
System.out.println("--------------------------------");
Person perosn = new Student();
System.out.println(perosn instanceof Student);//true子类创建的对象
System.out.println(perosn instanceof Person);//true类创建的对象
System.out.println(perosn instanceof Object);//true父类创建的对象
System.out.println(perosn instanceof Teacher);//false
// System.out.println(perosn 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 Teacher);//编译报错
//System.out.println(student instanceof String);//编译报错
}

null用instanceof跟任何类型比较时都是false

if(null instanceof String)//false

左边的对象实例不能是基础数据类型：

double b;
if(b instanceof Double)//编译报错

左边的对象实例和右边的类不在同一个继承树上

String name;
if(name instanceof Double)//编译报错

• 类型转换

public static void main(String[] args){
//类型之间的转化： 高--------低
//高
低
Person obj = new Student();
//将obj这个对象转换位Student类型，我们就可以用Student类型的go方法了！
Student
student = (Student) obj;
//或者
((Student) obj).go();
//子类转换为父类，可能丢失自己本来的一些方法
Student s1 = new Student();
s1.go();
Person person = s1;
//person.go()//X ， 无法调用
}
/*
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型，不用强制转换；
3.父类转换成子类，需要强制转换；
4.方便方法的调用，减少重复代码，简洁
*/

5 static详解

静态变量和静态方法:

package com.operator.test02;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
public class Student extends Person{
private static int age;//静态变量
private double score;//非静态变量
public static void go(){//静态方法
//run();静态方法不可以直接调用非静态方法，需要实例化对象才可以
Student s = new Student();
s.run();
}
public static void walk(){
go();//静态方法可以调用静态方法
}
public void run(){//非静态方法
go();//非静态方法可以调用静态方法
}
public static void main(String[] args) {
Student s1 = new Student();
//------------------------------------------
System.out.println(Student.age);
//System.out.println(Student.score);非静态属性不可以之间通过类名调用非静态属性
System.out.println(s1.age);
System.out.println(s1.score);//非静态属性必须通过实例化再调用
//------------------------------------------
Student.go();//静态方法可以之间通过类名调用
//Student.run();非静态方法不可以直接通过类名调用
s1.go();
s1.run();//非静态方法必须通过实例化对象再调用
}
}

静态代码块：

静态代码块只执行一次

public class Person {
//第二个执行,一般来赋初始值
{
//代码块（匿名方法）
System.out.println("匿名方法块");
}
//第一个执行,但是只执行一次
static{
//静态代码块（匿名静态方法）
System.out.println("静态方法块");
}
//第三个执行
public Person(){
System.out.println("构造器");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("==================");
Person person2= new Person();
}
/*
输出：
静态方法块
匿名方法块
构造器
==================
匿名方法块
构造器
*/
}

静态导入包（很少这么用，只做了解）

import static java.lang.Math.randon;//不加static会报错
public class Test{
public static void main(String[] args){
System.out.println(random());
}
}

6. final

如果是由final，则表示是常量，并且final修饰的类不能被继承，断子绝孙

public final class Person{
}
public class student extends Person{//编译报错，person是final修饰的，不可以继承
}

7.抽象类和接口

7.1 抽象类

• abstract修饰符可以用来修饰方法，也可以来修饰类，分别表示抽象方法和抽象类
• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
• 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
• 抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的
• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

public abstract class action {
//方法的约束~有人帮我们实现，适合宏观写框架
//abstract,抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
}
//抽象类的所有方法，继承它的子类，必须实现抽象类的所有方法，除非这个子类也是抽象类
public class A extends action {
@Override
public void doSomething() {
}
}

特点：

1. 抽象类不能new，只能靠子类去实现它，是一个约束！
2. 抽象类里面可以写普通方法
3. 抽象方法必须在抽象类中
4. 抽象的抽象：约束

思考：

抽象类存在构造器吗？存在构造器

抽象类存在的意义？将共性抽象出来，节省代码量，提高开发效率

（就比如游戏里面创建一个角色，角色刚开始都一样，这是共性，后来可以重写一些方法，使角色升级，这是个性）

7.2 接口

类（extends）都是单继承，但是接口可以多继承！！！

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有！
• 接口：只有规范（抽象方法）！自己无法写方法，它是专业的约束，约束和实现分离，很多时候都是面向接口编程
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”
• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
• OO（面向对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具有抽象能力的语言，就是因为设计模式所研究的，实际上是如何合理地去抽象。

声明类的关键字是class，声明接口的关键字是interface

//interface 定义的关键字
//接口都需要有一个实现类，实现类一般都是impl结尾
public interface UserService {
//接口中所有方法都是抽象的，默认是public abstract
//定义增删改查
void add(String name);//默认public abstrac
void delete(String name);
void update(String name);
void quary(String name);
}

public interface TimeService {
void time();
}

//架构师的抽象思维是否优秀
//抽象类 ：extends 单继承
//类 可以实现接口， 用implements（实现）+接口， 可以是多继承
//实现了接口的类
//通过接口可以实现多继承
public class UserServiceImpl implements UserService,TimeService{
//在接口里面定义常量，默认public static final,但是一般没有人在接口里面定义常量
//int age = 99;
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void quary(String name) {
}
@Override
public void time() {
}
}

接口的作用:

1. 约束
2. 定义一些方法，让不同的人实现
3. 接口里面的方法都是public abstract
4. 接口常量都是public static fianl
5. 接口不能实例化，因为接口不是类，没有构造方法
6. implements可以实现多个接口
7. 必须重写接口里面的方法

8.内部类以及OOP实战

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类就是外部类。

内部类的分类：

1.成员内部类

public class Outer {
private int id=10;//默认值
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//内部类可以来获得外部类的私有属性和私有方法
public void getId(){
System.out.println("outer id:"+id);
}
}
}

public class Application03 {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
}
}
/*
输出：
这是内部类的方法
outer id:10
*/

2.静态内部类

public class Outer {
private int id=10;//默认值
public void out(){
System.out.println("这是外部类的方法");
}
//静态内部类先初始化，就不能直接访问到id了，要是想要访问id，旧的将id也变成static
//静态内部类无法访问非静态属性，因为静态时先执行的，非静态还没来得及执行
public static class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
}
}

public class Application03 {
public static void main(String[] args) {
Outer outer = new Outer();
}
}

3.局部内部类

//写在方法里面（局部内部类）
public class Outer {
//定义在方法里面的类
//局部内部类
public void method(){
class inner{
public void in(){
}
}
}
}

4.匿名内部类

package com.operator.test03;
import com.operator.test02.UserService;
public class Application03 {
public static void main(String[] args) {
//没有名字初始化类，不用讲实例保存到变量中
//匿名内部类
new Apple().eat();
//内部类高阶玩法,实现接口
//匿名内部类/匿名接口
new UserService03(){
@Override
public void eat() {
}
};
}
}
//同一个文件下只能有一个public类，但是同一个类里面，可以有多个public内部类
class Apple{//也算内部类
public void eat(){
System.out.println("eat");
}
}
interface UserService03{
void eat();
}

最后

以上就是灵巧冬瓜为你收集整理的Java面向对象编程（基础）Java面向对象编程（OOP）的全部内容，希望文章能够帮你解决Java面向对象编程（基础）Java面向对象编程（OOP）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。