首页 > 编程语言 >Java基础2

Java基础2

时间：2023-12-27 22:34:13浏览次数：25  
标签：Java void 基础 System public class println 代码

1.抽象类

在Java中，抽象类（Abstract Class）是一种特殊类型的类，它不能被实例化，而是用于被其他类继承。抽象类可以包含抽象方法和具体方法。

以下是关于抽象类的一些关键点：

  1. 定义抽象类：

    • 使用abstract关键字定义抽象类。
    • 不能实例化抽象类，即不能使用new关键字创建抽象类的对象。 
      abstract class Shape {
    // 抽象方法
    abstract void draw();

    // 具体方法
    void display() {
        System.out.println("Displaying shape");
    }
}
     

  2. 抽象方法：

    • 抽象方法是在抽象类中声明但没有实现的方法。
    • 子类必须提供对抽象方法的具体实现。
    • 抽象方法使用abstract关键字声明，不包含方法体。 
      abstract class Shape {
    abstract void draw();
}

       

  3. 子类继承抽象类：

    • 子类使用extends关键字继承抽象类。
    • 子类必须提供对抽象方法的实现，否则子类也必须声明为抽象类。 
      class Circle extends Shape {
    // 实现抽象方法
    void draw() {
        System.out.println("Drawing a circle");
    }
}
     

  4. 抽象类的作用：

    • 提供一种模板或基类，定义一些通用的属性和方法。
    • 强制子类提供对抽象方法的实现，确保子类的一致性。

  5. 抽象类与接口的比较：

    • 抽象类可以包含具体方法，而接口只能包含抽象方法。
    • 一个类只能继承一个抽象类，但可以实现多个接口。
    • 接口更灵活，适用于多继承的场景。 
      // 示例：使用抽象类和子类
abstract class Shape {
    abstract void draw();

    void display() {
        System.out.println("Displaying shape");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw();
        circle.display();

        Rectangle rectangle = new Rectangle();
        rectangle.draw();
        rectangle.display();
    }
}

上述例子中，Shape是抽象类，Circle和Rectangle是其子类，分别实现了抽象方法draw。

2.类的高级特性

  1. 继承（Inheritance）：

    • 允许一个类（子类）基于另一个类（父类）的定义来创建，并且可以使用父类的属性和方法。
    • 子类可以继承父类的非私有属性和方法，并且可以通过重写方法来实现多态。 
      class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    // 可以使用父类的eat方法
    // 也可以重写eat方法
    void eat() {
        System.out.println("Dog is eating");
    }
}

       

  2. 多态（Polymorphism）：

    • 多态允许同一个方法在不同的对象上表现出不同的行为。
    • 通过方法的重写和接口实现实现多态。 
      Animal myAnimal = new Dog();
myAnimal.eat();  // 调用的是Dog类的eat方法

  3. 封装（Encapsulation）：

    • 封装是将对象的状态和行为包装在一起，并对外部隐藏对象的内部细节。
    • 使用私有属性和公有方法来实现封装。 
      class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String newName) {
        name = newName;
    }
}

       

  4. 接口（Interface）：

    • 接口定义了一组抽象方法，类可以实现一个或多个接口。
    • 接口提供了一种多继承机制，类可以实现多个接口。 
      interface Drawable {
    void draw();
}

class Circle implements Drawable {
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

      这些高级特性使得Java的面向对象编程更加灵活和强大，允许开发者更好地组织和管理代码。

 3.代码块

在Java中，代码块是一组被包含在花括号 {} 中的代码语句。代码块可以出现在类、方法、循环或条件语句中。主要有两种类型的代码块：普通代码块和静态代码块。

1. 普通代码块（Instance Initialization Block）：

普通代码块用于定义在类中，不带任何修饰符。它在对象创建时执行，优先于构造方法。

public class Example {
    // 构造方法
    public Example() {
        System.out.println("Constructor");
    }

    // 普通代码块
    {
        System.out.println("Instance Initialization Block");
    }

    public static void main(String[] args) {
        Example obj = new Example();
    }
}

输出：

Instance Initialization Block
Constructor
 

2. 静态代码块（Static Initialization Block）：

静态代码块用于定义在类中，使用 static 修饰。它在类加载时执行，只执行一次。

public class Example {
    // 静态代码块
    static {
        System.out.println("Static Initialization Block");
    }

    // 构造方法
    public Example() {
        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        Example obj1 = new Example();
        Example obj2 = new Example();
    }
}

输出：

Static Initialization Block
Constructor
Constructor

 

3. 局部代码块（Local Block）：

局部代码块是在方法或语句中创建的代码块，用于限定变量的作用范围。

public class Example {
    public static void main(String[] args) {
        int x = 10;

        // 局部代码块
        {
            int y = 20;
            System.out.println(x);  // 可以访问外部代码块的变量
            System.out.println(y);
        }

        // System.out.println(y);  // 编译错误，y的作用范围仅限于上面的局部代码块
    }
}

 

在实际编程中，代码块常用于初始化块、资源管理、局部变量的作用范围控制等场景。静态代码块经常用于执行类加载时的初始化工作。

 

4.. 构造代码块

是定义在类中的一种特殊的代码块，它在对象被创建时执行，位于类中成员变量声明的位置，被花括号 {} 包围。构造代码块在每次创建对象时都会执行，优先于构造方法。

构造代码块的主要作用是在对象创建时执行一些初始化操作，与构造方法共同完成对象的初始化工作。下面是构造代码块的基本语法：

class MyClass {
    // 构造代码块
    {
        // 初始化代码
        // 这部分代码会在每次对象创建时执行
    }

    // 构造方法
    public MyClass() {
        // 构造方法代码
        // 这部分代码在对象创建时执行
    }
}

 

以下是一个示例，展示了构造代码块的使用：

public class Example {
    private int x;

    // 构造代码块
    {
        // 初始化代码
        x = 5;
        System.out.println("Constructing an object with x = " + x);
    }

    // 构造方法
    public Example() {
        // 构造方法代码
        System.out.println("Inside the constructor");
    }

    public static void main(String[] args) {
        Example obj = new Example();
    }
}

 

输出：

Constructing an object with x = 5
Inside the constructor

 

在上述示例中，构造代码块中的初始化代码在对象创建时执行，然后再执行构造方法的代码。构造代码块适用于在每次对象创建时都需要执行的初始化逻辑，可以提高代码的可维护性。

 4.匿名对象

在Java中，匿名对象是指没有明确赋值给任何变量的对象，通常在创建对象的同时调用其方法。匿名对象通常用于一次性的操作，不需要将对象保存到变量中。

以下是一个简单的示例，演示了匿名对象的使用：

public class Example {
    public static void main(String[] args) {
        // 创建匿名对象并调用方法
        new MyClass().display();
        
        // 创建匿名对象并传递参数
        int result = new Calculator().add(5, 3);
        System.out.println("Result: " + result);
    }
}

class MyClass {
    public void display() {
        System.out.println("Inside MyClass");
    }
}

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

 

 

在上述示例中，new MyClass().display()创建了一个匿名对象，并立即调用了其display方法。同样，new Calculator().add(5, 3)创建了一个匿名对象，并直接调用了其add方法。

匿名对象的使用通常适用于以下情况：

  1. 一次性使用： 当对象仅在一个地方使用一次，不需要重复引用时。
  2. 简化代码： 对于简单的操作，可以通过匿名对象减少代码行数。

需要注意的是，由于匿名对象没有被赋值给变量，因此无法再次使用或引用。如果需要多次使用对象，应该将其赋值给变量。

 5.内部类

在Java中，内部类是定义在另一个类内部的类。内部类有以下几种类型：

       内部类（Inner Class）：

  • 内部类是定义在其他类内部的类。
  • 内部类可以访问外部类的成员，包括私有成员。 
    class Outer {
    private int x;

    class Inner {
        void display() {
            System.out.println("Value of x: " + x);
        }
    }
}

  1. 成员内部类（Member Inner Class）：

    • 成员内部类是定义在另一个类的内部的类，并且它是外部类的成员之一。
    • 成员内部类可以访问外部类的成员，包括私有成员。
    • 成员内部类可以用static修饰，此时它就变成了静态内部类。 
      public class Outer {
    private int outerVar;

    // 成员内部类
    class Inner {
        void display() {
            System.out.println("OuterVar from Inner: " + outerVar);
        }
    }
}

       

    public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.display();
    }
}

     

  2. 局部内部类（Local Inner Class）：

    • 局部内部类是定义在方法内部的类。
    • 局部内部类只能在定义它的方法中访问，生命周期仅限于方法的执行过程。
    public class Outer {
    void outerMethod() {
        // 局部内部类
        class LocalInner {
            void display() {
                System.out.println("Inside Local Inner");
            }
        }

        // 创建局部内部类对象并调用方法
        LocalInner localInner = new LocalInner();
        localInner.display();
    }
}
    public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod();
    }
}

     

  3. 匿名内部类（Anonymous Inner Class）：

    • 匿名内部类是一种没有类名的局部内部类，通常用于实现接口或继承类。
    • 匿名内部类一般在创建对象的同时进行定义，适用于一次性使用的情况。 
      interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        // 使用匿名内部类实现接口
        Greeting greeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello, world!");
            }
        };

        greeting.greet();
    }
}

       

     

内部类提供了一种更灵活的组织代码的方式，并允许在一个类内部定义与外部类关联紧密的类。然而，过多地使用内部类可能会导致代码的复杂性增加，因此需要根据具体情况慎重选择使用内部类的方式。

   

标签：Java,void,基础,System,public,class,println,代码
From： https://www.cnblogs.com/zjx00/p/17931571.html

相关文章

  • 无涯教程-Java泛型 - 原始类型
    如果原始类型的类型参数在创建过程中未传递，则原始类型是通用类或接口的对象。以下示例将展示上述概念。packagecom.learnfk;publicclassGenericsTester{publicstaticvoidmain(String[]args){Box<Integer>box=newBox<Integer>();box.set......
  • 运行Java程序
    Java及环境变量：安装openjdk-8-jre-headlessls/usr/bin/java默认放在/usr/bin下，不需要额外设置PATH 提示：如果放在自定义位置，需要设置PATHexport PATH=$PATH:/opt/jdk8/bin运行Java程序：1.在Windows上开发和调试2.发布......
  • Java登陆第三十天——Cookie和Session
    会话会话就是客户端与服务器的一次交互。HTTP是一种无状态协议无状态：服务端不会记录客户端信息。有的时候，我们需要保存客户端的信息。对于登陆功能来说，保存客户端信息，可以避免客户端每访问都需要登陆一次至此，会话管理诞生。CookieCookie是一种客户端会话技术，并保存在......
  • JavaImprove--Lesson02--Object类，Objects工具类，封装类
    一.Object类Java中的Object类是所有类的超类，它是Java类层次结构的根类。这意味着所有的类都直接或间接地继承自Object类equals(Objectobj):用于比较两个对象是否相等。默认实现是比较对象的引用，但可以通过重写此方法来比较对象的内部状态。hashCode():返回对象的哈希码值，通......
  • 【Cpp 语言基础】 string 类型进阶使用
    大纲：1.特殊的初始化方式2.获取子串3.与<algorith>中对应的成员函数 ”串“类型类似于数组类型（C语言的字符串就是字符数组）。但是有一点不同之处，就是串经常作为一个整体才有实际的”意义“，而数组每个单元都有其”意义“。因此，“串”的操作中，很大部分是“串”的整体、局部......
  • java基础语法API之GUI图形化界面2
    一：概述在1中，已经对GUI图形化的基础知识做了个概述，2中主要以例子为载体说明。并且介绍时间监听机制二：具体说明<1>猜数字//创建窗体对象JFramejf=newJFrame();jf.setTitle("猜数字");jf.setSize(400,300);jf.set......
  • 无涯教程-Java泛型 - 参数类型
    泛型类可以具有参数化类型，其中类型参数可以替换为参数化类型。以下示例将展示上述概念。packagecom.learnfk;importjava.util.ArrayList;importjava.util.List;publicclassGenericsTester{publicstaticvoidmain(String[]args){Box<Integer,List<St......
  • Java的安装
    Ubuntu下的Java环境：1.JDK/JRE的安装2.java的环境变量3.运行普遍Java程序4.Java程序的运行脚本 1.先安装Java的软件包：JRE:openjdk-8-jre-headlessJDK: openjdk-8-jdk-headless安装命令：sudoaptinstall openjdk-8-jdk-he......
  • 无涯教程-Java泛型 - 多个类型
    泛型类可以具有多个类型参数。以下示例将展示上述概念。packagecom.learnfk;publicclassGenericsTester{publicstaticvoidmain(String[]args){Box<Integer,String>box=newBox<Integer,String>();box.add(Integer.valueOf(10),"HelloWorld")......
  • C# 中关于 T 泛型【C# 基础】
    C#中关于T泛型【C#基础】 阅读目录〇、前言一、泛型类型参数和运行时中的泛型1.1泛型类型参数1.2泛型类型的命名1.3运行时中的泛型1.4为什么要约束类型参数？二、泛型类三、泛型接口四、泛型方法五、泛型与数组六、泛型委托七、小小的总结回到顶......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99