Java学习笔记 | Java面向对象

最新推荐文章于 2024-07-06 16:47:20 发布

(⊙追\(^忆

最新推荐文章于 2024-07-06 16:47:20 发布

阅读量274

点赞数

分类专栏： Java学习笔记文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/qq_43702196/article/details/123381233

版权

Java学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

类与对象

类是一个模板：抽象，对象是一个具体的实例

方法

定义、调用

对象的引用

引用类型、基本类型（8类）

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

属性

字段（Field、成员变量）

默认初始化：

数字：0、0.0

char：u0000

boolean：false

引用：null

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

对象的创建和使用

必须使用new关键字创造对象，构造器 Person p1 = new Person();
对象的属性p1.name
对象的方法p1.sleep();

类

静态的属性属性

动态的行为方法

封装&继承&多态

1. 封装

该露的露，该藏的藏
- 程序设计追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用。
数据的隐藏
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

总之就是：属性私有，get/set

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

2. 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是”扩展“，子类是父类的拓展。
Java中只有单继承，没有多继承。
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚集等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上具有”is a“关系
子类继承父类，就会拥有父类全部方法（public）
在Java中，所有类都默认继承Object类
private属性和方法无法被继承

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

声明类：
```
final class 类名 {//类体}
```

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

`super`：super()调用父类构造方法

子类默认构造器中默认调用父类无参构造器，且必须在第一行
super必须只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法

super & this

代表的对象不同
- this：本身调用者这个对象
- super：代表父类对象的应用
前提：
- this：没有继承也可以使用
- super：只能在继承条件时才可以使用
构造方法：
- this()：本类的构造
- super()：父类的构造

static 关键字

stati被称为静态，可以用来修饰类的属性,方法,代码块,内部类

static属性：静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。

static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用
在static方法内部只能访问类的static属性，不能访问类的非static属性。

static方法只能调用static方法，因为static方法与类同时加载到内存中

静态代码块与匿名代码块

public class Person {
    
        {
            //代码块（匿名）
            System.out.println("匿名代码块");
        }

        static{
            //静态代码块
            System.out.println("静态代码块");
        }
        
        public Person(){
            System.out.println("构造方法");
        }

        public static void main(String[] args) {
            Person p = new Person();
        }

}

运行结果：

静态代码块
匿名代码块
构造方法

以上说明在使用构造器创建对象前，会先运行静态代码块和匿名代码块。

但static代码块仅在程序第一次创建对象时运行

public class Person {

        {
            //代码块（匿名）
            System.out.println("匿名代码块");
        }

        static{
            //静态代码块
            System.out.println("静态代码块");
        }

        public Person(){
            System.out.println("构造方法");
        }

        public static void main(String[] args) {
            Person p = new Person();
            System.out.println("=============");
            Person p2 = new Person();
        }

}

运行结果：

静态代码块
匿名代码块
构造方法
=============
匿名代码块
构造方法

静态导入包

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {

    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }

}

方法重写：重写和属性无关

public class B {

    public static void test(){
        System.out.println("B->test");
    }

}
public class A extends B {

    public static void test(){
        System.out.println("A->test");
    }

}
public class Application {

    public static void main(String[] args) {

        A a = new A();
        a.test();
        B b = new A();
        b.test();
    }
}

运行结果：

A->test
B->test

重写只和非静态方法有关，且是public类型方法
静态方法只和“B b = new A();”中等号左边的类型有关
重写：需要有继承关系，子类重写父类方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小：public > protected > Default > private
- 抛出的异常：范围可以缩小，但不能扩大
重写，子类的方法和父类必须要一致，仅方法体不同

为什么要重写？

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

多态

一个对象的实际类型是确定的，可以指向的引用类型是不确定的（父类的引用指向子类）。

public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son sun");
    }
}

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();//Student 能调用的方法都是自己或父类的
        Person s2 = new Student();//Person可以指向子类，但不能调用子类独有方法
        Object s3 = new Student();
        s1.run();//输出：son sun
        s2.run();//输出：son sun
        //s3.run();//由于s3是Object类型，不含有run()方法，所以编译失败
    }
}

对象能执行哪些方法,主要看代码等号左边的对象类型，实际运行时，执行右边对象重写后的方法。

多态注意事项

多态是方法的多态，属性没有多态
父类和子类,有继承关系（String s = new Student();无法运行）
存在条件：继承关系，方法需要重写，父类引用指向子类对象

不能被重写的方法：

static方法，属于类，不属于实例
final修饰
private方法

instanceof (引用类型类型转换)

判断一个对象是什么类型

类型之间的转换（父类 --子类）

父类调用子类的独有方法需要强制转换。

public class Person {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son sun");
    }
    public void jump(){
        System.out.println("jump");
    }
}
public class Application {
    public static void main(String[] args) {
        Person s1 = new Student();//父类引用指向子类的对象
        ((Student)s1).jump();//强制类型转换
    }
}

子类转换为父类有可能丢失子类的一些方法

public class Application {

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.jump();//可以找到这个方法
        Person p1 = s1;
        //p1.jump();//无法找到这个方法
    }
}

抽象类（对类的约束，抽象的抽象）

abstract

特点：

不能new出来抽象类对象，只能靠子类去实现它
抽象类中可以写普通方法
抽象方法必须在抽象类中
抽象类中可以没有抽象方法，但有抽象方法的一定要声明为抽象类

抽象类也有默认构造器
抽象类存在的意义：提高开发效率

接口

对比：

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法（专业的约束，约束和实现分离（面向接口编程））

接口中的所有定义的方法其实都是公开抽象的（public abstract）

接口中的所有定义的属性都是常量（public static final)

public interface UserService {

    //常量
    public static final int age = 99;
    void add(String name);//接口中的所有定义都是抽象的
    void delete(String name);
    void update(String  name);
    void query(String name);
}
public interface TimeService {

    void timer();
}
//类可以实现接口，也可以利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口的作用：

约束
定义一些方法，让不同的人实现
方法都是public abstract
属性都是public static final
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
继承接口的类必须要重写接口中的所有方法

(⊙追\(^忆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记 | Java面向对象

类与对象类是一个模板：抽象，对象是一个具体的实例方法定义、调用对象的引用引用类型、基本类型（8类）对象是通过引用操作的：栈->堆属性字段（Field、成员变量）默认初始化：数字：0、0.0 char：u0000 boolean：false 引用：null修饰符属性类型属性名 = 属性值对象的创建和使用必须使用new关键字创造对象，构造器 Person p1 = new Person();对象的属性p1.name对象的方法p1
复制链接

扫一扫