初识java——javaSE（6）抽象类与接口【求个关注！】

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量923 收藏 26
点赞数 19
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77993957/article/details/139048089
版权

文章目录

前言

一 抽象类

1.1 抽象类的概念

抽象类是一种特殊类，它为子类提供一个的通用的模版，使得子类继承
对于抽象类所描述的事物，现实世界中是不存在的，比如动物，现在世界中不存在动物这个实体！

1.2 抽象类的语法：

abstract：
抽象类由abstract关键字修饰，放置在class关键字之前：

举例：

abstract class Animal{

}

抽象方法：抽象方法是指由abstract关键字修饰的方法，它不可以有方法体。抽象方法只能存在于抽象类中。
抽象方法与抽象类的关系是：有抽象方法的类一定是抽象类，抽象类中不一定有抽象方法。

abstract class Animal{
    public int a ;
    public static void b (){
        System.out.println("抽象类当中的静态方法");
    }
       //此抽象方法并没有方法体！
      abstract void shout();


}

在抽象类被子类继承之后，如果子类不是抽象类，那么本抽象类的抽象方法必须被实现重写，重写成有方法体的方法。

abstract class Animal{
    public int a ;
    public static void b (){
        System.out.println("抽象类当中的静态方法");
    }

      abstract void shout();


}
 abstract    class Dog extends Animal{

    @Override
    void shout() {
        System.out.println("狗发出汪汪叫");
    }
  
}

抽象类不能够被实例化对象：
因为现实世界中，并不存在抽象类对应的事物，它是一个概念，所以不能被实例化对象！

在这里插入图片描述

1.3 抽象类与普通类的区别：

abstract class Animal{
    public int a ;
    public void  eat(){
          System.out.println("动物正在吃饭");
      }
    public static void b (){
        System.out.println("抽象类当中的静态方法");
    }

      abstract void shout();


}

我们发现抽象类除了不能够实例化对象外，其他功能与普通类并无差异，我们也可以不实例化父类的对象，为什么还要引进抽象类呢？

因为这样可以有效地避免错误，当我们并没有重写父类中的抽象方法，
或者实例化了父类的对象，这时编译器会报错，这相当于编译器为我们加了一层保险。
（有时父类不需要进行实例化对象且不能引用父类原有的方法，需要重写）

二 接口

2.1 接口的概念

//接口在日常生活中有插座的接口，有电脑USB的接口，这些接口都遵循着各自统一的标准
//这体现了在一堆设备（比如一些电脑）中有着共同的标准。
 
//在java中
//与类一样，接口也是一种引用数据类型
// 接口的思想即一些类公共的行为规范。
// 接口的含义是：具有....的特性
// 比如会游泳——狗，鱼等，这个行为是这两个类共有的特性。

举例：

在这里插入图片描述

接口的名称一般已**I**为首字母！

public interface ISwiming {
    void func1();
    
}

2.2 接口的语法

2.2.1 接口的各个组成

interface关键字：
接口的定义格式与类的定义格式并无区别，唯一的不同之处在于关键字class换成关键字interface

接口中的成员变量：

接口中的成员变量默认是由 public static w7final关键字修饰的，且必须进行初始化。

public interface ISwiming {
   public static final   int a = 10 ;
      }

在这里插入图片描述

 因为java默认接口中的成员变量被public static final修饰，所以在编写代码时
 可以省略掉前面的三个词

在这里插入图片描述

接口中的方法：

接口中的方法除default关键字修饰的与static修饰的之外，其他的方法均由public abstract修饰。

抽象方法：
在这里插入图片描述

因为除default关键字修饰与static关键字修饰之外的方法，编译器均默认为public 修饰的抽象方法（不能替换成别的修饰符），所以我们可以简写成:

     void func1();

静态方法：

在接口中的静态方法默认被public修饰,不能换成别的修饰符

在这里插入图片描述
注意：

 接口在创建时，尽量遵循代码简洁的原则，能冗余的修饰符都省略掉！

default修饰的方法：
在jdk8以后，接口中default修饰的方法可以有方法体！

在这里插入图片描述
注：

 接口中不允许有构造方法！

在这里插入图片描述

2.2.2 接口之间的继承

对于类只能继承一个类，接口可以继承多个接口
举例：


interface A{
    
}
interface B{
    
    
}
interface C extends A,B{
    
    
}

2.3 接口的实现

一个接口的实现需要有相应实现的类。
类实现接口时的关键字为implements
位于类名与接口名之间！
举例：

interface A{
    void   func1();
}
interface B{
    void func2();

}
interface C extends A,B{
    void func3();

}

class test1 implements C{
    @Override
    public void func3() {
        
    }

    @Override
    public void func2() {
        
    }

    @Override
    public void func1() {
        
    }
}

代码解析：
在上面的代码中，test类，实现了接口C，

类在实现接口时，必须重写实现接口中的抽象方法

所以必须实现func3()方法，由于接口C继承了接口A与接口B，所以test类还需要实现func1()与func2()方法！

   一个类可以实现多个接口

interface A{
    void   func1();
}
interface B{
    void func2();

}
class test1 implements A ,B{

    @Override
    public void func2() {

    }

    @Override
    public void func1() {

    }
}

接口不可以实例化对象

在这里插入图片描述
但是接口可以接收实现类的对象：

interface A{
    void   func1();
}
interface B{
    void func2();

}
interface C extends A,B{
    void func3();

}

class test1 implements C{
    @Override
    public void func3() {

    }

    @Override
    public void func2() {

    }

    @Override
    public void func1() {

    }
}

public class Test {
    public static void main(String[] args) {
        /*   C c = new C() ;*/
        C c = new test1();

    }
}

2.4 接口实现多态

//创建一个关于游泳的接口
interface ISwiming2{
    void func1();

}
//创建一个Dog类实现接口
class Dog implements ISwiming2{
    String name;

    public Dog(String name) {
        this.name = name;
    }

    public void func1(){
        System.out.println( this.name+ "会游泳");

    }
}
//创建一个Fish类，实现接口
class Fish implements ISwiming2{
    String name;

    public Fish(String name) {
        this.name = name;
    }

    public void func1(){
        System.out.println( this.name+"会游泳");
    }
}
//测试类
public class Test {
//创建一个静态方法，参数为接口类型 ，用于接受实现了接口的类的对象
    public static void func2(ISwiming2 iSwiming2){
        iSwiming2.func1();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        func2(dog);
        Fish fish =new Fish("小鱼儿");
        func2(fish);
    }
}

在这里插入图片描述

三 Object类

3.1 Object类是什么？

Object类是java中提供的类，它可以说是所有的类父类，所有的类都继承Object类
Object是开发中最高统一类型的形参。

例如：下面的代码中，虽然Dog的直属父类是Animal，但是Animal默认继承了Object类，所以Dog类也继承了Object类

class Animal{



}
class Dog extends Animal{

}

3.2 关于Object类中的几个方法：

在这里插入图片描述

Object中的方法只有这些，这里先主要了解画横线的三个方法，初步了解。

3.2.1 equals方法

equals方法用于两个对象间的比较

在java中,Object类的equals方法默认为：

在这里插入图片描述

此方法只能比较基本数据类型，而不能比较引用数据类型（因为只能比较地址），
为了比较引用数据类型，需要对方法进行重写

代码：

class Dog {
    String name;
    int age;

    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }
//对equals方法的重写！
    @Override
    public boolean equals(Object o) {
        //Object需要先进行强制类型转换
        Dog tmp = (Dog) o;
        //分别比较年龄与名字！
        return tmp.age == this.age
                && tmp.name.equals(this.name);

    }

}
    public class Test {
        public static void main(String[] args) {
            Dog dog1 = new Dog("旺财",10);
            Dog dog2 = new Dog("旺财",10);
            
            System.out.println(dog1 == dog2);
            System.out.println(dog1.equals(dog2));

        }
    }

在这里插入图片描述

3.2.2 hashcode方法

hashcode方法用于算出对象具体的地址，这涉及到数据结构，因为还没学到数据结构，我们暂时把它当做一个内存地址。

代码：

class Dog {
    String name;
    int age;

    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }


}
    public class Test {
        public static void main(String[] args) {
            Dog dog1 = new Dog("旺财",10);
            Dog dog2 = new Dog("旺财",10);
            System.out.println(dog1.hashCode());
            System.out.println(dog2.hashCode());

        }
    }

在这里插入图片描述

对于两个对象结果得出的值不相同，假如对于相同名字与年龄的对象，我们想得出同样的值，此时该怎么办？重写方法：

原本Object类中的hashcode方法：
在这里插入图片描述
此方法的修饰符有native，说明此方法的实现是由c与c++语言实现的，我们无法查看它是怎样实现的。

重写后的方法：

    public int hashCode() {
    //根据名字与年龄属性来判断哈希值
        return Objects.hash(name, age);
    }

在这里插入图片描述
此时两个对象的哈希值就相同了！

3.2.3 toString方法

Object中的toString类实现：

在这里插入图片描述
这个方法用于打印引用类型变量的相关值

举例：

public class Test {
    public static void main(String[] args) {
        //创建一个整型数组   
          int [] arr1 = {1,2,3,4,5};
         System.out.println(arr1);
        System.out.println(arr1.toString());

    }
}

在这里插入图片描述
结果相同：如果我们想直接打印数组中的内容怎么办？

java提供的Arrays类中重写了Object类中的toString方法：

public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

重写后的方法可以将将数组中的内容以字符串中的形式打印出来！

public class Test {
    public static void main(String[] args) {
         
          int [] arr1 = {1,2,3,4,5};
         System.out.println(arr1);
        System.out.println(arr1.toString());
        //调用重写之后的方法:
        System.out.println(Arrays.toString(arr1));
    }
}

在这里插入图片描述

四 内部类

4.1 内部类的概念

    //内部类是定义在另一个类内部的类。
    相对的，包含内部类的类，我们称为外部类

4.2 几种内部类

 //内部类有四种
    //静态内部类
    //实例(构造)内部类
    //局部内部类
    //匿名内部类

静态内部类：

静态内部类的格式：静态内部类定义在外部类中，与外部类的成员变量，方法同级。

静态内部类可以看做是外部类的一个静态成员，所以在静态内部类实例化时，
不需要先实例化外部类！

在class关键字前被static关键字修饰。

class Dog{
    String name;
    int age;
// 静态内部类的创建！
    static class Inner{
        String name;
        public void shout(){
            System.out.println("我是静态内部类");
        }
    }


}

关于静态内部类的语法：
（1）

   静态内部类可以定义自己的成员变量，成员方法，静态方法，在类的组成方面与普通类没有区别！

 static class Inner{
        String name;
        public void shout(){
            System.out.println("我是静态内部类");
        }
        public static void func1 (){};
        
    }

（2）静态内部类的实例化：

        Dog.Inner inner = new Dog.Inner();


 静态内部类可直接实例化，其中Dog.Inner 是个整体,Dog.Inner() 也是一个整体

（3）静态内部类访问外部类成员问题：

1）

        静态内部类不能直接访问外部类的非静态成员变量与方法。
        （因为非静态成员变量与方法依赖于对象！）

public class Test {
    public static void main(String[] args) {
        Dog.Inner inner = new Dog.Inner();
       inner.func1();


    }
}
class Dog{
     public   static String sex = "男" ;
    String name = "李四";
    int age;
// 静态内部类的创建！
    static class Inner{
        public static void func1 (){
            System.out.println(name);

        };

    }


}

在这里插入图片描述

2）

 静态内部类可以访问外部类中的静态成员与静态方法！
（因为外部类中的静态成员与静态方法不依赖于对象，而依赖于类）

public class Test {
    public static void main(String[] args) {
        Dog.Inner inner = new Dog.Inner();
       inner.func1();
    }
}
class Dog{
     public   static String sex = "男" ;
    String name = "李四";
    int age;
// 静态内部类的创建！
    static class Inner{
        public static void func1 (){
         System.out.println(sex);

        };
    }
}

在这里插入图片描述

3）

静态内部类不能使用外部类的this关键字（因为this关键字依赖于对象，不依赖于类）。

实例内部类:

实例内部类是定义在一个类内部，且不是静态内部类的类。
实例内部类可以看做是外部类的一个非静态成员。
实例内部类的实例化前，必须先实例化外部类对象。

1）实例内部类的实例化：

public class Test {
    public static void main(String[] args) {
    //先实例化外部类对象后：
   Dog dog1 = new Dog();
   //在外部类对象中，实例化内部类（实例内部类）对象
   Dog.Test2 test2 =  dog1. new Test2();
   test2.func1();

    }
}
class Dog{
    String name;
    int age;
   
//实例内部类
 public   class Test2{
     int a ;
     public void func1(){
        System.out.println("实现了实例内部类");
     }

}

}

在这里插入图片描述
代码分析：

Dog.Test2 test2 =  dog1. new Test2();

Dog.Test2 是一个整体，代表内部类类名，test2是内部类对象名称
dog1是外部类对象，后面跟new Test2()意味着在dog1对象中实例化内部类对象！

2）实例内部类访问外部类的成员：

因为实例内部类可以看做是外部类的一个非静态成员，
所以实例内部类可以直接访问外部类中所有的属性与方法。

public class Test {
    public static void main(String[] args) {
   Dog dog1 = new Dog();
        Dog.Test2 test2 =  dog1. new Test2();
        test2.func2();

    }
}
class Dog{
    String name = "王五";
    int age = 10;
   public static int  b =  5;
   private void test1(){
       System.out.println("尝试访问外部类中方法");
   }
 public   class Test2{
     int a ;
     public void func2(){
     //访问外部类中的name与age属性
         System.out.println("我的名字是"+name+", 年龄是"+age);
     //返回外部类中的静态属性b    
         System.out.println(b);
    //访问外部类中的方法     
         test1();
     }
}

}

在这里插入图片描述

结果表明，全部访问成功！

3）实体内部类中this关键字：

this关键字本质上就是当前引用的对象，在实体内部类中，
this既可以指向自己，又可以指向外部类（因为实体内部类可以看作是外部类的一个成员）

这相当于有两个不同的this。

 当调用实例内部类中的成员时，用this.x(x代表成员名)，
 当调用外部类中的成员时，用外部类名.this.x (x代表成员名)

举例：

class Dog{
    String name = "王五";
    int age = 10;
   public static int  b =  5;
   private void test1(){
       System.out.println("尝试访问外部类中方法");
   }
   
 public   class Test2{
     String name = "张三";
     int age = 9;
     int a ;

     public void func2(){
         //直接使用this可以访问内部类中的成员
         System.out.println("我的名字是"+this. name+", 年龄是"+ this.age);
         //那如何通过this访问到外部类中的成员呢？
         System.out.println("我的名字是"+ Dog. this. name+", 年龄是"+ Dog.this.age);

     }

}
}

在这里插入图片描述

局部内部类

局部内部类是定义在外部类的方法或代码块中的类，可以把它看做一个局部变量
局部内部类的语法格式与普通类相同。

局部内部类的实例化：

局部内部类只能在所在的方法或代码块中进行实例化，而不能去其他位置进行实例化：

public class Test {
    public static void main(String[] args) {

    Dog dog = new Dog();
    dog.func1();

    }
}
class Dog{
    String name = "张三";
   public void shout(){
       System.out.println("狗发出汪汪叫");
   }


  public void func1(){
     class Test3{
         int a ;
         public void func2(){
             System.out.println("我的名字叫"+name);
         }

     }
     //只能在所在的方法中实例化对象
   Test3 test3 = new Test3();
     test3. func2();


  }


}

在这里插入图片描述
局部内部类对外部类中成员的引用：

局部内部类可以引用外部类中所有的成员！

举例：
在这里插入图片描述

 引用name时，编译器并不报错！

匿名内部类

匿名内部类的格式：

   new 类型 (){
         重写方法;
    };
//类型可以是普通类，抽象类，接口

匿名内部类格式的由来：

我们在继承一个类或者实现一个接口时，往往需要新建一个类：

//创建一个Animal接口
interface  Animal{
    void shout();
}
//创建一个Dog类，实现Animal接口
class Dog implements Animal{
    public void shout(){
        System.out.println("狗发出汪汪叫");
    }
    
}
//创建测试类
public class Test {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.shout();
    }
}

在这里插入图片描述

当我们只需要创建一次对象时，这种方法就比较麻烦，
更多的是当我们需要实现一个接口时，并不想创建一个实现类，而只是想实现接口中
的某一方法时，单纯创建一个实现类过于麻烦。
因为上述的两种情况，java中引入了匿名内部类的概念。

匿名内部类举例：

匿名内部类在创建时，即已经进行实例化对象，
在实现接口时，可以通过接口引用来接收对象
在实现抽象类时，也可以通过接口引用来接收对象
在继承普通类时，则不能通过普通类引用来接收对象

//创建一个Animal接口
interface  Animal{
    void shout();
}
//创建一个Test类
public class Test {
    public static void main(String[] args) {

   //使用Animal引用来接收匿名内部类所创建的对象
   
      Animal a =  new Animal(){
            public void shout(){
                System.out.println("狗发出汪汪叫");
            }
        };
        a.shout();
    }
}

在这里插入图片描述

 也可以直接在匿名内部类后引用成员：

 new Animal(){
            public void shout(){
                System.out.println("狗发出汪汪叫");
            }

         }.shout();

在这里插入图片描述

像这样，接口的实现类，子类，我们用到了，但是类名是什么，我们是不知道的，
它是在需要的地方直接定义和实例化的，因此它是“匿名”的
因为匿名内部类在创建时本身就在实例化，所以匿名内部类的创建可以在  可以创建
对象  的任何位置进行创建。

外部类对几种内部类访问的情况：

外部类对静态内部类的访问：
对于静态内部类中静态的成员变量与方法，外部类可以通过静态内部类类名进行调用。
对于非静态成员，外部类则需要实例化静态内部类对象进行调用！

class Animal{
    String name;
    public void test(){
    //调用静态内部类中的func1方法
        Test.func1();
        //调用静态内部类中的age属性
        System.out.println(Test.age);
    }


    static class Test{
        static   int age;
        public static void func1(){
            System.out.println("静态内部类中的静态成员方法");
        }

    }

}
//创建测试类
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.test();
    }
}

在这里插入图片描述

外部类对实例内部类的访问：

外部类对于实例内部类中的静态成员访问时，也需要实例内部类类名调用。
对于实例内部类中非静态成员访问时，需要先创建实例内部类对象，再进行调用（在外部类中创建实例内部类对象时，不需要先创建外部类对象）

class Animal{
    String name;
    public void test2(){
        System.out.println(Test2.a);
        Test2 test2 = new Test2();
        test2.shout();
    }
    public class Test2{
        static int a = 10;
        public void shout(){
            System.out.println("调用实例化中的非静态方法");
        }
    }
}

public class Test {
    public static void main(String[] args) {
       Animal animal = new Animal();
        animal.test2();
    }
}
外部类对局部内部类的访问：

前面我们讲过局部内部类可以看作外部类的一个局部变量，局部内部类的作用域仅限于其所在的代码块或方法中，因此外部类无法在该代码块之外访问局部内部类

外部类对局部内部类的访问，只能在局部内部类所在的方法中进行访问，前提是局部内部类的对象已经创建。

class Animal{


    public void func1(){
    //创建一个局部内部类
        class Test3{
             static  int a ;
            public void func2(){
                System.out.println("调用局部内部类中非静态方法");
            }
     
        }
        Test3 test3 = new Test3();
       //只能在局部内部类所在的方法中进行访问成员
       test3.func2();
    }
}
public class Test {
    public static void main(String[] args) {
       Animal animal = new Animal();
        animal.func1();
    }
}

在这里插入图片描述

龙ze
关注
  • 19
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
JavaSE之抽象的概念
07-21
这这文件里的内容适合Java初学者，这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE入门者学习，都是浅显易懂的话语，没有太多的官方话，绝对是你初学JavaSE的宝典，针对人群：刚入门的...
JavaSE之StringBuilder类与String类
07-21
这个文件里的内容适合Java初学者，String类为引用类，不属于基本数据类型，但是String类非常的重要，在后边学习的JavaSE中，几乎使用的全是String类，这个文件里边包含了对String字符串的拆分、拼接以及怎么声明进行...
初识java——javaSE （6）接口的实现——比较器与深拷贝，浅拷贝
2301_77993957的博客
05-25 1193
上一篇博客并没有将接口的内容阐述完毕，这篇博客继续阐述！
JavaSE学习——面向对象三大特性抽象类与接口内部类
NightFa1l的博客
05-07 263
Java面向对象 初识面向对象 面向过程&面向对象 面向过程思想 线性思维：第一步做什么，第二部做什么，条理清晰 大象放进冰箱里，需要三步 适合处理简单的问题 面向对象思维 物理类聚，分类的思想 适合处理复杂问题 整体上是面向思维的把握，但是具体还是要用面向过程实现 冰箱有一个方法，放物品（需要判断物品的体积，重量等） 面向对象编程（Object-Oriented Programing） 面向对象编程的本质： 以类的方式组织代码，以对象的组织（封装）数据 三大特性 封装 存在对对象数
初识Java——课堂笔记
qq_43617368的博客
04-14 279
学习Java的三个阶段 第一阶段: A:走出校园，迈进社会，走进企业成为了一名程序员 B：懂得团队协作，懂得项目版本如何控制、我们写的代码如何进行测试，项目如何上线运行等等基本功。当你掌握了这些东西之后就可以迈入第二阶段，一般在2~5年，薪资在10-25k 进入第一阶段需要掌握哪些知识 A：前端知识（作为一个后端工程师，要懂得前端。但是前端可以不懂后端） 1、Html（表单的各种请求）、CSS（绝...
【JavaSE】初识类和对象——this引用、构造方法
qq_41233305的博客
11-10 393
【JavaSE】类和对象——this 引用、构造方法
JavaSE基础——面向对象1：类与对象
冰羽
07-30 202
JavaSE基础——面向对象1：类与对象 文章目录JavaSE基础——面向对象1：类与对象一、编程思想1.面向过程编程（POP， Procedure Oriented Programming)2.面向对象编程（OOP，Object Oriented Programming)。3.面向接口编程（IOP，Interface Oriented Programming)4.面向切面编程（AOP，Aspect Oriented Programming）5.函数式编程（Function Programming）二、类与
初识Java——面向对象（一）
一只大鹏鹏的博客
02-27 317
面向对象(Object Oriented) 学习了半个月，终于结束了JavaSE的学习，之后的学习就进入了Java的第二阶段——面向对象。面向过程和面向对象作为Java语言中特别重要的思想，但是相对而言这两个知识比较偏向于抽象概念，重在理解，所以在总结过程中为了方便理解会尽量不用官方语言，注重自己的个人理解。 首先，什么是面向过程和面向对象？ 很简单，就从字面上理解，这两个都为动宾结构，面向...
Java基础系列——（1）初识Java
weixin_46468815的博客
04-26 383
正所谓万丈高楼平地起，想要学好一个知识，需要打好基础，去理解它的来龙去脉。现在就让大家跟着提提一起学Java基础，为今后的学习打下结实的基础吧！
初识JAVA— javaSE
decade72的博客
04-16 197
对于一个一直努力学习前端并一心只想成为一名前端开发工程师的小菜鸟来说，在大四这年因为不得已的原因需要重新学习另外一门语言，大名鼎鼎且声名远扬的JAVA。学习java的第一天最明显的感觉是不同于javascript的弱类型特性，java对于类型的要求十分严谨。另一个强烈的感受是——学好程序始祖C。广义的java可分为三个部分，javaSE主要定义了java语言的语法标准，数据类型等；javaEE主要...
JavaSE基础——面向对象1：类与对象-----005
墨苒孤的博客
04-12 116
JavaSE基础——面向对象1：类与对象 一、编程思想 一般来说，计算机语言要处理的就两个方面的内容：数据和算法。数据是程序使用和处理的信息；算法是程序使用的方法。 1.面向过程编程（POP， Procedure Oriented Programming) 核心思想：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 举例说明：以把大象放入冰箱为例，我们首先定义一个拿到大象的函数，然后定义一个开冰箱的函数，然后定义一个放大象的函数，然后定义一个关冰箱的函数，
抽象类思维导图.xmind
03-12
Java,JavaSe,抽象类，思维导图
西安云工厂xaygc.com_JavaSE_04类与对象_旺旺老师
09-22
学习java,讲的很不错
抽象类_接口_多态_继承整合案例.docx
08-04
抽象类_接口_多态_继承整合案例.。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 831
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 904
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1025
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 834
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java抽象类与接口结合使用教程
在这个PPT的示例中，我们看到一个抽象类`A`不仅包含了抽象方法`printA()`，还定义了一个内部接口`B`，这展示了Java语言的灵活性。内部接口`B`有一个抽象方法`printB()`。类`X`继承自抽象类`A`并实现了`printA()`方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值