AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java基础知识复习01：从基础知识---面向对象（后续会更新）（4）

2023-10-12 48
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 12.2 接口的抽象方法1、接口的抽象方法定义 /*在任何版本的Java中，接口都能定义抽象方法。格式：public abstr

12.2 接口的抽象方法

1、接口的抽象方法定义

 

/*
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称（参数列表）；
注意事项：
1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2.这两个关键字修饰符，可以选择性地省略。
 */
public interface MyInterface {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这也是抽象方法
    abstract void methodAbs2();
    //这也是抽象方法
    public void methodAbs3();
    //这也是抽象方法
    void methodAbs4();
}
2、接口的抽象方法使用
/*
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称（参数列表）；
注意事项：
1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2.这两个关键字修饰符，可以选择性地省略。
 */
public interface MyInterface {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这也是抽象方法
    abstract void methodAbs2();
    //这也是抽象方法
    public void methodAbs3();
    //这也是抽象方法
    void methodAbs4();
}
public class MyInterfaceImpl implements MyInterface{
    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法！");
    }
    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法！");
    }
    @Override
    public void methodAbs3() {
        System.out.println("这是第三个方法！");
    }
    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法！");
    }
}
public class demo03Interface {
    public static void main(String[] args) {
        //错误写法！不能直接new接口对象使用。
//        MyInterface inter=new MyInterface();
        //创建实现类的对象使用
        MyInterfaceImpl impl=new MyInterfaceImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }
}
12.3 接口的默认方法定义和接口的默认方法使用
/*
从Java 8 开始，接口里允许定义默认方法。
格式：
public default 返回值类型 方法名称（参数列表）{
方法体
}
备注：接口当中的默认方法，可以解决接口升级问题。
 */
public interface MyInterfaceDefault {
    //抽象方法
     public abstract  void methodAbs();
    //新添加了一个抽象方法
//    public abstract void methodAbs2();
    //新添加的方法，改成默认方法
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}
public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs(){
        System.out.println("实现了抽象方法，AAA");
    }
}
public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs(){
        System.out.println("实现了抽象方法，BBB");
    }
    @Override
    public void methodDefault(){
        System.out.println("实现了类B覆盖重写了接口的默认方法");
    }
}
/*
1.接口的默认方法，可以通过接口实现类对象，直接调用。
2.接口的默认方法，也可以被接口实现类进行覆盖重写。
 */
public class demo04 {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceDefaultA a=new MyInterfaceDefaultA();
        //调用抽象方法，实际运行的是右侧实现类
        a.methodAbs();//实现了抽象方法，AAA
        //调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault();//这是新添加的默认方法
        System.out.println("=================");
        MyInterfaceDefaultB b=new MyInterfaceDefaultB();
        b.methodAbs();//实现了抽象方法，BBB
        b.methodDefault();//实现了类B覆盖重写了接口的默认方法
    }
}
12.4 接口的静态方法定义和接口的静态方法使用
/*
从Java 8 开始，接口里允许定义静态方法。
格式：
public static 返回值类型 方法名称（参数列表）{
方法体
}
提示：就是将abstract或者static即可，带上方法体
 */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法！");
    }
}
public class MyInterfaceImpl implements MyInterfaceStatic {
}
/*
注意事项：
不能通过接口实现类的对象来调用接口当中的静态方法。
正确方法：
通过接口名称，直接调用其中的静态方法。
格式：
接口名称。静态方法名（参数）；
 */
public class Demo05Interface {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceImpl impl=new MyInterfaceImpl();
        //错误写法:impl.methodStatic();
        //直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}
12.5 接口的私有方法使用
/*
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案：
从Java 9开始，接口当中允许定义私有方法。
1.普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称（参数列表）{
方法体
}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称（参数列表）{
方法体
}
 */
public interface MyInterPrivateA {
    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodCommon();
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodCommon();
    }
    public default void methodCommon(){
        System.out.println("AAAAAA");
        System.out.println("BBBBBB");
        System.out.println("CCCCCC");
    }
}
public class MyInterfacePrivateImpl implements MyInterPrivateA{
    public void methodAnother(){
    }
}
静态比较
public interface MyInterPrivateB {
    public static void methodStatic1(){
        System.out.println("静态方法1");
        methodStaticCommon();
    }
    public static void methodStatic2(){
        System.out.println("静态方法2");
        methodStaticCommon();
    }
    public /*private*/ static void methodStaticCommon(){
        System.out.println("AAAAAA");
        System.out.println("BBBBBB");
        System.out.println("CCCCCC");
    }
}
public class Demo06 {
    public static void main(String[] args) {
        MyInterPrivateB.methodStatic1();
        MyInterPrivateB.methodStatic2();
    }
}

12.6 接口的常量定义和使用

接口当中也可以定义”成员变量“，但是必须使用public static final 三个关键字。

从效果上看，这其实就是接口的【常量】。

格式：

public static final 数据类型 常量名称 = 数据值；

备注：

一旦使用final关键字进行修饰，说明不可改变。

 

注意：

一旦使用final关键字进行修饰，说明不可改变。

 

1.接口当中的常量，可以省略public static final ,注意：不写也照样写这样。

2.接口当中的常量，必须进行赋值：不能不赋值。

3.接口当中常量的名称，使用完全大写的字母，用下划线进行分割。

 

public interface MyInterfaceConst {
    //这其实就是一个常量，一旦赋值，不可修改
    public static final int NUM=10;//final:最终的
}
public class Demo05Interface {
    public static void main(String[] args) {
        //访问接口当中的常量
        System.out.println(MyInterfaceConst.NUM);
    }
}

12.7 接口内容小结

 

12.8 继承父类并实现多接口

 

使用接口的时候，需要注意：

1.接口是没有静态代码块或者构造方法的

2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口

格式：

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{

//覆盖重写所有抽象方法

}

3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要重盖覆写一次即可。

4.如果实现类没有覆盖重写所有接口当中的所有抽象方法。

5.如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

6.一个类如果直接父类当中的方法，和接口当中的默认方法产生冲突，优先用父类当中的方法。

public interface MyInterfaceA {
    public abstract void methodA();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法AAA");
    }
}
public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法BBB");
    }
}
public  abstract class MyInterfaceAbstract 
implements  MyInterfaceA,MyInterfaceB{
    @Override
    public void methodA() {
    }
//    @Override
//    public void methodB() {
//
//    }
    @Override
    public void methodAbs() {
    }
    @Override
    public void methodDefault() {
    }
}
public class MyInterfaceImple/*extends Object*/ 
implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }
    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了A、B接口都有的(Abs)抽象方法");
    }
    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行覆盖重写");
    }
    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }
}
public interface MyInterface {
    public default void method(){
        System.out.println("接口的默认方法");
    }
}
public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
}
//继承优先于接口实现
public class Zi extends Fu implements MyInterface{
}
public class Demo02Interface {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.method();
    }
}
12.9 接口之间的多继承
/*
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。
注意事项：
1.多个父接口当中的抽象方法如果重复，没关系
2.多个父类接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。
 */
public class demo03Relations {
}
public interface MyInterfaceA {
    public abstract void menthodA();
    public abstract void menthodCommon();
    public default void methodDefault(){
        System.out.println("AAAA");
    }
}
public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void menthodCommon();
    public default void methodDefault(){
        System.out.println("BBB");
    }
}
/*
这个子接口当中有有几个方法？答：四个。
menthodA:来源于接口A
menthodB:来源于接口B
menthodCommon:同时来源于接口A和B
menthod:来源于我自己
 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    public abstract void menthod();
    @Override
    default void methodDefault() {
    }
}
public class MyInterfaceImpl implements MyInterface{
    @Override
    public void menthod() {
    }
    @Override
    public void menthodA() {
    }
    @Override
    public void menthodCommon() {
    }
    @Override
    public void methodB() {
    }
}

 

十三、多态

什么是多态

同一个对象，在不同时刻表现出来的不同形态

多态的前提

要有继承或实现关系

要有方法的重写

要有父类引用指向子类对象

 

成员访问特点

成员变量

编译看父类，运行看父类

成员方法

编译看父类，运行看子类

13.1 多态的格式与使用

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式：

父类名称 对象名=new 子类名称（）；

或者：

接口名称 对象名=new 实现类名称（）；

 

public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}
public class Zi extends Fu{
    @Override
    public void method(){
        System.out.println("子类方法！");
    }
}
public class demo14 {
    public static void main(String[] args) {
        //使用多态的写法
        //左侧父类的引用，指向了右侧子类的对象
        Fu obj=new Zi();
        obj.method();
        obj.methodFu();
    }
}
13.2 成员变量的使用特点
public class Fu {
    int num=10;
    public void showNum(){
        System.out.println(num);
    }
}
public class Zi extends Fu{
    int num=20;
    int age=16;
}
/*
访问成员变量的两种形式：
1.直接通过对象名称访问成员变量，看等号右边是谁，优先用谁，没有则向上找。
2.间接通过成员方法访问成员变量，看该方法属于谁。优先用谁，没有则向上找。
 */
public class demo15 {
    public static void main(String[] args) {
        //使用多态的写法，父类引用指向子类对象
        Fu obj=new Zi();
        System.out.println(obj.num);//父：10
        System.out.println("============");
        //子类没有覆盖重写，就是父：10
        //子类有覆盖重写，就是子：20
        obj.showNum();
    }
}

13.3 成员方法的使用特点

在多态的代码当中，成员方法的访问规则是：

看new 的是谁，就优先用谁，没有则向上找。

 

口诀：

编译看左边，运行看右边。

 

对比一下：

成员变量：编译看左边，运行还看左边。

成员方法：编译看左边，运行看右边。

 

public class Fu {
    int num=10;
    public void showNum(){
        System.out.println(num);
    }
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}
public class Zi extends Fu{
    int num=20;
    int age=16;
    @Override
    public void showNum(){
        System.out.println(num);
    }
    @Override
    public void method(){
        System.out.println("子类方法");
    }
    //@Override
    public void methodZi(){
        System.out.println("子类特有方法");
    }
}
public class demo15Method {
    public static void main(String[] args) {
        Fu obj=new Zi();//多态
        obj.method();//父子都有，优先用子
        obj.methodFu();//子类没有，父类有，向上找到父类
        //编译看左边，右边是Fu,Fu当中没有methodZi方法，所以编译错误。
      //  obj.methodZi();//错误写法
    }
}

 

13.4 对象的转型

1、向上转型

 

public abstract class Animal {
    public  abstract void eat();
}
public class Cat extends Animal{
@Override
    public void eat(){
    System.out.println("猫吃鱼");
}
}
public class demo16 {
    public static void main(String[] args) {
        //对象的向上转型，就是：父类引用指向之类对象。
        Animal animal=new Cat();
        animal.eat();
    }
}

 

2、向下转型

 

 

public class Cat extends Animal{
@Override
    public void eat(){
    System.out.println("猫吃鱼");
}
    public void catchMouse() {
        System.out.println("猫抓老鼠");
}
}
public class Dog extends Animal{
    @Override
            public void eat(){
        System.out.println("狗吃屎");
    }
    public void watchHouse(){
        System.out.println("狗看家");
    }
}
public abstract class Animal {
    public  abstract void eat();
}
/*
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
解决方案：
用对象的向下转型【还原】
 */
public class demo16 {
    public static void main(String[] args) {
        //对象的向上转型，就是：父类引用指向之类对象。
        Animal animal=new Cat();//本来创建的时候是一只猫
        animal.eat();//猫吃鱼
      //  animal.catchMouse();//写法错误
        //向下转型，进行“还原”动作
        Cat cat=(Cat) animal;
        cat.catchMouse();//猫抓老鼠
        //向下是错误的向下转型
        //本来new的时候是一只猫，现在非要当作狗
        //错误写法！编译不会报错，但是运行会出现异常
        //java.long.ClassCastException. 类转换异常
        Dog dog=(Dog) animal;
    }
}
 用instanceof关键字进行类型判断
/*
如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例
 */
public class demo16Instanceof {
    public static void main(String[] args) {
        //Animal animal=new Cat();//本来是一只猫
        Animal animal=new Dog();//本来是一只狗
        animal.eat();//猫吃鱼
        //如果希望调用子类特有方法，需要向下转型
        //判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog){
            Dog dog=(Dog) animal;
            dog.watchHouse();
        }
        //判断一下animal本来是不是Cat
        if (animal instanceof Cat){
            Cat cat=(Cat) animal;
            cat.catchMouse();
        }
      giveMePet(new Dog());
    }
    public static void giveMePet(Animal animal){
        if (animal instanceof Dog){
            Dog dog=(Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat){
            Cat cat=(Cat) animal;
            cat.catchMouse();
        }
    }
}
13.6 笔记本USB接口案例
public interface USB {//interface接口
    public abstract void open();//打开设备；abstract：抽象
    public abstract void close();//关闭设备
}
public class Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
    //使用USB设备的方法，使用接口作为方法的参数
    public void usbDevice(USB usb){
        usb.open();//打开设备
        if (usb instanceof Mouse){
            //一定要先判断
            Mouse mouse=(Mouse) usb;//向下转型
            mouse.click();
        }else if (usb instanceof Keyboard){//先判断
            Keyboard keyboard=(Keyboard) usb;//向下转型
            Keyboard.type();
        }
        usb.close();//关闭设备
    }
}
//鼠标就是一个USB设备
public class Mouse implements USB{
    @Override
    public void open(){
        System.out.println("打开鼠标");
    }
    @Override
    public void close(){
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("鼠标点击");
    }
}
//键盘就是一个USB设备
public class Keyboard implements USB{
    @Override
    public void open(){
        System.out.println("打开键盘");
    }
    @Override
    public void close(){
        System.out.println("关闭键盘");
    }
    public static void type(){
        System.out.println("键盘输入");
    }
}
public class demo17 {
    public static void main(String[] args) {
        //首先创建一个笔记本电脑
        Computer computer=new Computer();
        computer.powerOn();
        //准备一个鼠标，供电脑使用
 //       Mouse mouse=new Mouse();
        //首先进行向上转型
        USB usbMouse=new Mouse();
        //参数是USB类型，我正好传递进去的是USB鼠标
        computer.usbDevice(usbMouse);
        System.out.println("============");
        //创建一个USB键盘
        Keyboard keyboard=new Keyboard();//没有使用多态写法
        //方法参数是USB类型，传递进去的是实现类对象
        computer.usbDevice(keyboard);//正确写法!也发生向上转型
        //使用子类对象，匿名对象，也可以
        //computer.usbDevice(new keyboard());
        computer.powerOff();
        System.out.println("=======");
        method(10.0);//正确写法：double----->double
        method(10);//正确写法：int------>double
        int a=30;
        method(a);//正确写法：int------>double
    }
    public static void method(double num){
        System.out.println(num);
    }
}

13.7 final关键字

1、概念与四种用法

final关键字代表最终、不可改变的：

 

常见四种用法：

1.可以用来修饰一个类。

2.可以用来修饰一个方法

3.还可以用来修饰一个局部变量

4.还可以用来修饰一个成员变量

 

/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
//. . .
}
含义：当前这个类不能有任何的子类。（大太监）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子）
 */
public class MyClass /*extends Object*/{
    public void method(){
        System.out.println("方法执行！");
    }
}
2、用于修饰成员方法
/*
当final关键字用来修饰一个方法的时候，这时候就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称（参数列表）{
//方法体
}
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
 */
 //抽象类的定义
public abstract class Fu {
    public final void method(){
        System.out.println("父类方法执行！");
    }
    //抽象方法的定义
    public abstract void methodAbs();
}
public class Zi extends Fu{
    @Override
    public void methodAbs(){
    }
    //错误写法!不能覆盖重写父类当中final的方法
//@Override
    //public void method(){
       // System.out.println("子类覆盖重写父类的方法！");
    //}
}
3、用于修饰局部变量
public class Student {
     private String name;
     public Student(){
     }
    public Student(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class demo01 {
    public static void main(String[] args) {
          int num1=10;
        System.out.println(num1);//10
        num1=20;
        System.out.println(num1);//20
        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        //“一次赋值，终生不变”
        final int num2=200;
        System.out.println(num2);//200
        //正确写法！只要保证有唯一一次赋值即可
        final int num3;
        num3=30;
        System.out.println(num3);//30
        //对于基本类型来说，不可变说的是变量当中的数据不可改变。
        //对于引用类型来说，不可改变的是变量当中的地址值不可改变。
        Student stu1=new Student("赵丽颖");
        System.out.println(stu1);
        System.out.println(stu1.getName());//赵丽颖
        stu1=new Student("霍建华");
        System.out.println(stu1);
        System.out.println(stu1.getName());//霍建华
        System.out.println("========");
        final Student stu2=new Student("高圆圆");
        System.out.println(stu2);
        System.out.println(stu2.getName());//高圆圆
        stu2.setName("高圆圆圆圆圆");
        System.out.println(stu2.getName());//高圆圆圆圆圆
    }
}
4、用于修饰成员变量
/*
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
 */
public class Person {
    //private String name;
    private final String name;
    public Person() {
        name="关晓彤";
    }
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    //public void setName(String name) {
    //    this.name = name;
   // }
}
类名作为形参和返回值（应用） 
1、类名作为方法的形参 
方法的形参是类名，其实需要的是该类的对象 
实际传递的是该对象的【地址值】 
2、类名作为方法的返回值 
方法的返回值是类名，其实返回的是该类的对象 
实际传递的，也是该对象的【地址值】
public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }
    public Cat getCat(){
        Cat c=new Cat();
        return c;
    }
}
public class demo04 {
    public static void main(String[] args) {
        CatOperator co=new CatOperator();
        Cat c=new Cat();
        co.useCat(c);
        System.out.println("=========");
        Cat c2=co.getCat();
        c2.eat();
    }
}
抽象类作为形参和返回值 
方法的形参是抽象类名，其实需要的是该抽象类的子类对象 
方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
public class AnimalOperator {
    public void useAnimal(Animal a){
        a.eat();
    }
    public Animal getAnimal(){
        Animal a=new Cat();
        return a;
    }
}
public class demo05 {
    public static void main(String[] args) {
        AnimalOperator ao=new AnimalOperator();
        Animal a=new Cat();
        ao.useAnimal(a);
        System.out.println("=========");
        Animal a2=ao.getAnimal();
        a2.eat();
    }
}
接口作为形参和返回值 
方法的形参是接口名，其实需要的是该接口的实现类对象 
方法的返回值是接口名，其实返回的是该接口的实现类对象


文章标签：
Java
关键词：
Java面向对象
Java基础知识
Java基础知识面向对象
Java基础知识面向对象后续
鹿茸
目录
相关文章
土木林森
|
19天前
|
Java 关系型数据库 数据库
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析，详细介绍了面向对象设计的五大核心原则：单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统，不仅适用于Java，也适用于其他面向对象编程语言。
土木林森
13 2
杀死一只知更鸟debug
|
2月前
|
Java 编译器
封装，继承，多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性：封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态，继承允许新类扩展现有类的功能，而多态则允许对象在不同情况下表现出不同的行为，这些特性共同提高了代码的复用性、扩展性和灵活性。
杀死一只知更鸟debug
42 2
封装，继承，多态【Java面向对象知识回顾①】
刘大猫.
|
2月前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
刘大猫.
35 4
杀死一只知更鸟debug
|
2月前
|
Java
接口和抽象类【Java面向对象知识回顾②】
本文讨论了Java中抽象类和接口的概念与区别。抽象类是不能被实例化的类，可以包含抽象和非抽象方法，常用作其他类的基类。接口是一种纯抽象类型，只包含抽象方法和常量，不能被实例化，且实现接口的类必须实现接口中定义的所有方法。文章还比较了抽象类和接口在实现方式、方法类型、成员变量、构造方法和访问修饰符等方面的不同，并探讨了它们的使用场景。
杀死一只知更鸟debug
26 0
接口和抽象类【Java面向对象知识回顾②】
Codelinghu
|
1月前
|
存储 Java 程序员
Java基础-面向对象
Java基础-面向对象
Codelinghu
16 0
源码星辰
|
2月前
|
安全 Java Go
面向对象程序设计语言：Java
Java语言语法和C语言和C++语言很接近，很容易学习和使用，Java丢弃了C++中很少使用的、很难理解的、令人迷惑的特性，Java语言不使用指针，而是引用，并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧
源码星辰
56 2
java的细水长流
|
2月前
|
Java 开发者
Java 面向对象
Java 是一种面向对象的编程语言，通过对象与类的概念组织代码和数据。面向对象编程的核心包括类、对象、继承、多态、封装和抽象。类是对象的蓝图，定义了属性和行为；对象则是类的实例。继承允许子类继承父类的属性和方法，增强代码复用性；多态则支持通过相同接口调用不同类型对象的行为，包括方法重载和重写。封装通过公共方法隐藏对象细节，提高安全性；抽象则对对象特征进行提炼，通过抽象类和接口实现。理解这些概念有助于设计高效、可维护的 Java 应用程序。
java的细水长流
22 0
众所周知
|
3月前
|
Java 开发者 C++
抽象类与接口的深度解析！Java面向对象的终极挑战
Java面向对象的终极挑战
众所周知
51 2
历年考试不作弊
|
2月前
|
Java 开发者
Java编程之旅：探索面向对象的力量
【9月更文挑战第16天】在编程的世界中，Java以其强大的面向对象编程特性而闻名。本文将带你走进Java的世界，一起探索类与对象的奥秘，学习如何通过封装、继承和多态性构建健壮的软件系统。无论你是初学者还是有经验的开发者，本文都旨在提供实用的代码示例，帮助你提升Java技能。准备好开始这段旅程了吗？让我们启程吧！
历年考试不作弊
14 0
请看我回答~
|
3月前
|
存储 Java 数据库连接
Java编程之旅：从基础到高级，探索面向对象的力量
【8月更文挑战第31天】本文是一篇深入浅出的Java编程指南，旨在通过生动的例子和实际代码演示，带领读者从Java的基础语法起步，逐步深入到面向对象的核心概念，最后探讨如何在实际项目中应用这些知识。无论你是编程新手还是有一定经验的开发者，这篇文章都将为你提供有价值的见解和实用的技巧。
请看我回答~
26 0

热门文章

最新文章

  • 1
    Java 生成 UUID
  • 2
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 3
    【Java用法】使用Java导出word文档的解决方案（适用于从服务器上下载到本地电脑）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    JDK6笔记（5）----JDBC4
  • 6
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 7
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 8
    （十三）java类的继承
  • 9
    Java基础之004-面向对象
  • 10
    java 定时调用 bat
  • 1
    Dubbo03【管理控制台和监控中心搭建】，Java开发实用必备的几款插件
    56
  • 2
    Java中int[]与Integer[]相互转化的方法，java基础知识面试重点总结
    35
  • 3
    Java 并发编程中的锁优化策略
    34
  • 4
    Java一分钟之-设计模式：装饰器模式与代理模式
    63
  • 5
    《手把手教你》系列技巧篇（四十六）-java+ selenium自动化测试-web页面定位toast-下篇（详解教程）
    63
  • 6
    刷题两个月，从入门到字节跳动offer丨GitHub标星16k+，美团Java面试题
    65
  • 7
    《MySQL 入门教程》第 05 篇 账户和权限，Java高并发编程详解深入理解pdf
    53
  • 8
    Java的前景如何，好不好自学？，万字Java技术类校招面试题汇总
    54
  • 9
    es集群安装，邮储银行java面试
    79
  • 10
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    98

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问