JAVA基础(三大特性)

2022-10-13 10:27:28

JAVA语言的一些基础部分与C语言类似,故本文直接从面向对象开始说起:

首先需要了解几个概念:

对象:客观存在并且能够区分的个体,在JAVA中万事万物皆对象。

:具有相同特征或者行为的对象的集合

类是对象的概括,对象是类的实例

类的声明:

class{
//成员变量;
//成员方法;
}

修饰符:

在一个类中应该有构造器:用于创建对象;

在构造器中应该注意:

①构造器名必须和类名一致。
②构造器没有返回值类型。
③任何类都含有构造器。
④如果没有显式地定义类的构造器,则系统会为该类提供一个默认的无参的构造器。一旦在类中显式地定义了构造器,系统就不会再为这个类提供默认的构造器了。如需要使用无参的构造器,需要自行在类中进行定义。

对象是类的实例:类名 对象名=new 类名();

对象调用方法:对象.方法;

static关键字:静态修饰符,可以修饰:

        变量:被static修饰的变量为静态变量,JVM只为静态分配一次内存,可通过类直接访问

        方法:在静态方法中只能访问静态成员变量或静态方法,静态方法可以通过类名直接调用,故被static修饰的方法调用的是一个类,而不是一个对象,因此不能使用this和super关键字。static方法必须被实现,不能是abstract。

        代码块:随着类的加载而加载,与方法不同的是代码块是不用调用的,只要使用代码块所在的类,代码块就会被调用。

        内部类:被static修饰的内部类切断了与外界的联系。

注意:static final修饰的可以简单理解为全局常量。

final关键字:可以修饰:

        基本数据类型:被final修饰的基本数据类型一旦被赋值后,其值不能被改变。

        引用数据类型:被final修饰的引用数据类型,地址不能修改,但是对象本身的属性可以修改。

        方法:被final修饰的方法是将方法锁定,继承类不能修改此方法。

        类:被final修饰的类不能被任何类继承,会“断子绝孙”!

abstract关键字:可以修饰:

        方法:被abstract修饰的方法就是没有被实现的方法,没有方法体,注意被abstract修饰的方法不能用private修饰,否则子类无法访问到该方法;

        类:被abstract修饰的类为抽象类,此类的主要作用就是被继承,继承类必须实现抽象类中的所有抽象方法。

代码块:代码块是类的成分之一,在Java中,使用 { } 括起来的代码被称为代码块。

        分类:

                   局部代码块:用于限定变量生命周期,及早释放,提高内存利用率。

                                        局部代码块中声明的变量在代码块外部访问不到!

                   静态代码块:必须要被static修饰,主要用于对静态属性进行初始化。

                                       必须放在类中, 随着类一起加载执行,且只执行一次。

                   实例(构造)代码块:调用构造方法都会执行,并且在构造方法前执行。

                                                        无static修饰。属于对象,与对象的创建一起执行的。

                                                        每次调用构造器初始化对象,实例代码块都要自动触发执行                                                                一次。

                                                        实例代码块实际上是提取到每一个构造器中去执行的。

                                                        实例代码块中的内容在构造方法前执行。

                   同步代码块:一种多线程保护机制,在Java高级部分的多线程部分会详细说明。

Java面向对象的三大特性:封装、继承、多态

一、封装

        所谓封装就是在定义一个类时,将类的成员变量进行私有化,用private修饰,私有属性只能在类的内部被访问,如果类外部想要访问类的私有属性时,需要提供一些public方法(setXX()和getXX())。

方法的重载:方法重载就是在一个类中,有相同名称的函数,但函数的形参不同。

重载的规则:

                1、在同一个类中;

                2、方法名称必须相同;

                3、方法的参数列表不相同;

                4、方法重载与方法的返回值类型无关。

this关键字:this 关键字是 Java 常用的关键字,可用于任何实例方法内指向当前对象,也可指向对其调用当前方法的对象,或者在需要当前类型对象引用时使用。

this.属性名:调用对象的属性

this.方法名:调用对象的方法


题目概述:编写一个超市购物程序,如果购物者所要购买的程序超市中有,则提示购物者买到了某商品,否则提示购物者白跑一趟。

package primary;

import java.util.Objects;

public class Product {
    private String productName;

    public Product(String productName) {
        this.productName = productName;
    }

    public Product() {
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product product = (Product) o;
        return Objects.equals(productName, product.productName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(productName);
    }
}
package primary;

public class Market {
    private String marketName;
    private int count=0;
    private int kinds;
    public Product[] products;
    public  Market(String marketName,int kinds) {
        products=new Product[kinds];
        this.marketName = marketName;
        this.kinds=kinds;
    }
    public void putProduct(Product product)
    {
        if(product!=null&&count<kinds){
            products[count++]=product;
        }

    }
    public Product getProduct(int i){
        return products[i];
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getKinds() {
        return kinds;
    }

    public void setKinds(int kinds) {
        this.kinds = kinds;
    }
    public Market() {
    }

    public String getMarketName() {
        return marketName;
    }



    public void setMarketName(String marketName) {
        this.marketName=marketName;
    }

}
package primary;

public class Person {
    private Product wantBuy;

    public Product getWantBuy() {
        return wantBuy;
    }

    public Person() {
    }

    public void setWantBuy(Product wantBuy) {
        this.wantBuy = wantBuy;
    }

    public Person(Product wantBuy) {
        this.wantBuy = wantBuy;
    }
   
    public void findthing(Product wantBuy,Market market){
        boolean flag=false;
        for(int i=0;i<market.getCount();i++){
            if(wantBuy.equals(market.getProduct(i))){
               flag=true;
               break;
            }
        }
        if(flag){
            System.out.println("在" + market.getMarketName() + "买到了" + wantBuy.getProductName() + "!");
        }else{
            System.out.println(market.getMarketName() + "没有" + wantBuy.getProductName() + ",白跑一趟!");
        }
    }

}
package primary;

import java.util.Scanner;

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

        Product p1=new Product("豆浆");
        Product p2=new Product("西瓜");
        Product p3=new Product("茉莉花茶");
        Product p4=new Product("鸡蛋");
        Product p5=new Product("青菜");
        Product p6=new Product("牛奶");
        Market m1=new Market("嘉润超市",10);
        Market m2=new Market("好又多超市",10);
        m1.putProduct(p1);
        m1.putProduct(p3);
        m1.putProduct(p6);
        m2.putProduct(p1);
        m2.putProduct(p2);
        m2.putProduct(p5);
        m2.putProduct(p4);
        System.out.println("请问您要去买什么:");
        Scanner sc1=new Scanner(System.in);
        Product wantBuy=new Product(sc1.nextLine());
        System.out.println("请问您要去哪个超市买:(1.嘉润;2.好又多)");
       Scanner sc2=new Scanner(System.in);
       int selection=sc2.nextInt();
        Person person=new Person();
        if(selection==1){
            person.findthing(wantBuy,m1);
       }else if(selection==2){
            person.findthing(wantBuy,m2);
        }else{
            System.out.println("您的输入有误!");
        }


    }


}

运行结果 :

请问您要去买什么:
豆浆
请问您要去哪个超市买:(1.嘉润;2.好又多)
1
在嘉润超市买到了豆浆!

 成员内部类:在JAVA中允许在一个类内部定义一个类

在成员内部类中允许访问外部类的所有成员。

创建内部类对象的具体语法格式如下:

外部类名.内部类名 变量名=new 外部类名().new 内部类名();

注意:当内部类被声明私有,外界将无法访问

二、继承

       在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类。子类继承父类的属性和方法,使得子类对象(实例)具有父类的特征和行为。

继承应该注意的问题:

(1)在Java中,类只支持单继承,不允许多重继承。也就是说一个类只能有一个直接父类

(2)多个类可以继承一个类

(3)B类继承A类,C类继承B类,C类同样也继承了A类,A类也是C类的父类

(4)在Java中,子类和父类是一种相对概念,一个类可以是某个类的父类,也可以是另一个类的子类。

子类通过extends继承父类

方法的重写:在继承关系中,子类会自动继承父类中定义的方法,但有时在子类中需要对继承的方法进行一些修改,即对父类的方法进行重写。

但是在方法重写中应该注意:子类中重写后的方法应该和父类中的方法有相同的函数名、参数列表、返回值,但是子类不能比父类拥有更严格的访问权限。

方法重写和方法重载的区别:

方法重载:
1、同一个类中
2、方法名相同,参数列表不同(参数顺序、个数、类型)
3、方法返回值、访问修饰符任意

方法重写:
1、有继承关系的子类中
2、方法名相同,参数列表相同(参数顺序、个数、类型),方法返回值相同
3、子类的访问修饰符访问范围需要大于等于父类的访问范围
super关键字:子类可以通过super关键字调用父类的方法、属性、构造器。

注意:如果子类要调用父类的构造器时super()只能出现在第一行,并且只能出现一次。

this关键字和super关键字不让同时出现,以为this关键字和super关键字都必须出现在构造方法的首行。

抽象类:被abstract修饰的类,含有抽象方法。

抽象类的定义规则如下:

(1)包含一个以上抽象方法的类必须是抽象类。

(2)抽象类和抽象方法都要使用abstract关键字声明。

(3)抽象方法只需声明而不需要实现。

(4)如果一个类继承了抽象类,那么该子类必须实现抽象类中的全部抽象方法。

接口:接口是一种特殊的类,由全局常量和公共的抽象方法组成,不能包含普通方法。

接口中常量前面的访问修饰符默认为public static final,并且在接口中方法的默认访问权限为public abstract。

子类通过implements来实现接口,子类可以实现多个接口,并且子类必须实现接口中的所有抽象方法。

抽象类和接口的区别:

(1)抽象类是一个类,允许含有构造方法和私有的成员变量,但接口中不允许;

(2)抽象类中可以含有普通方法,但是接口中只能有抽象方法;

(3)一个类只能继承一个抽象类,但可以实现多个接口。

(4)一个类继承抽象类时只需重写类中的抽象方法,而实现接口时必须重写其所有方法。

三、多态

在Java中,多态是指不同对象在调用同一个方法时表现出的多种不同行为。

在Java中,多态的两种主要形式:方法重载、方法重写

对象类型转换:

(1)向上转型:子类对象->父类对象

在向上转型中,系统会自动完成

(2)向下转型:父类对象->子类对象

在向下转型中首先应利用instanceOf进行一个判断,否则可能会出现异常

Person p=new Man();
if(p instanceOf Man){
Man p1=(Man) p;
}

注意:Man类是Person类的一个子类!

instanceOf关键字:判断一个对象是否是某个类(或接口)的实例。

语句格式为:对象名 instanceOf 类名

  • 作者:过ԅ(¯ㅂ¯ԅ)
  • 原文链接:https://blog.csdn.net/m0_62404808/article/details/125296777
    更新时间:2022-10-13 10:27:28