Java面向对象编程（基础）

最新推荐文章于 2024-07-19 17:37:28 发布

leo hope

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量471

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_52795571/article/details/123362823

版权

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

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

3.1构造器

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

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

&面向对象小总结

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

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

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

属性：字段Field，成员变量

默认初始化：

数字：0 ， 0.0

char：u0000

boolean：false

引用： null

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

对象的创建和使用

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

对象的属性 person.name

对象的方法 person.sleep()

类：

静态属性：属性

动态方法：方法

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());
    }
}

意义：

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

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
方法重写

注意：

子类可以继承父类的所有public方法
Ctrl + H可以看继承的关系树
在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注意点：

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

super和this的对比：

代表的对象不同:

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

super：代表父类对象的引用

使用前提：

this：没有继承也可以使用

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

调用构造方法的区别：

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 总结

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

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

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

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

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

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

为什么需要重写？

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

重写快捷键：Alt + Insert

4.3 多态

动态编译：使类型的可扩展性增强（编译的时候才确定对象）
同一个方法可以根据发送对象的不同而采取多种不同的行为方式
一个的实际类型使确定的，但可以指向对象的引用的类型有很多（父类引用子类，有关系的类引用）
注意：多态是方法的多态，属性没有多态性
instanceof（类型转换->引用类型之间的转换）

4.3.1 多态存在的条件：

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

注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系。否则有类型转换异常！（ClassCastException!）
多态存在的条件：要有继承关系，方法需要重写，父类引用指向子类对象(Father f1 = new Son;)
有些方法不能重写：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() {

    }
}

特点：

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

思考：

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

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

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

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() {
    }
}

接口的作用:

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

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();
}

leo hope

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象编程（基础）

Java面向对象编程（OOP）1.初识面向对象1.1 面向过程步骤清晰简单，第一步做什么，第二步做什么…面对过程适合处理一下简单问题1.2 面向对象思维物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些类，然后对这些类进行单独思考，最后，才对某个分类下的细节进行面向过程思考面向对象适合处理复杂的问题，适合处理需要多人协作的问题！1.3 什么是面向对象本质：以类的方式组织代码，以对象的组织（封装）数据抽象三大特性：封装，继承，多态对于描述复杂的事物，为了从宏观上把握，
复制链接

扫一扫