Java6、7章复习 5.4

最新推荐文章于 2024-05-10 09:14:14 发布

Seal_heart_

最新推荐文章于 2024-05-10 09:14:14 发布

阅读量117

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Seal_heart_/article/details/124956907

版权

一、面向对象编程的概念

1-1 介绍类与对象

类与对象的定义

类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。 [1]

类与对象的关系

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

类型的声明

先声明类类型，然后再定义对象

类的定义对象

类其实就是一个模板，比如说类就好比一张房子的设计图纸，或者说是一个倒印模具，创建一个类就好比设计一张图纸，刻一个模板。对象就好比一座建好的房子，一个成型的模型，无疑想要一座房子或者一个模型都先需要一张图纸和一个模板，而这就是类和对象的关系。

1-2 创建类与对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。

实例化：使用关键字 new 来创建一个对象。

初始化：使用 new 创建对象时，会调用构造方法初始化对象。

对象由类的构造方法，实例化而来
例如：有一个类Student,那么对象的实例过程：

public class Student{
    String name;
   public static void main(String [] args){
           Student stu = new Student();//此处即创建了一个对象
   }
}

1-3 成员变量

成员变量是指类的一些属性定义，标志类的静态特征，它的基本格式如下：

【访问修饰符】【修饰符】【类型】【属性名称】= 【初始值】

访问修饰符：public（公共的）；protected（受保护的）；无修饰符和private（私有的）。

修饰符：对属性特征的描述：如static，final 等等。

类型：属性的数据类型，可以是任意类型。

属性名称：任何合法标识符。

初始值：赋值给属性的初始值。

举例：

public static int index = 0;

很多时候我们不希望成员变量使用默认值, 而是需要我们显式设定初值. 那么此时有五种方法供我们成员变量初始化：

1：默认初始化，即程序所赋予的默认值，上面已经讲过，此处不再过多陈述。

2：就地初始化：即在定义成员变量时便进行初始化，如下所示：

public String name = "张三";
public int age = 18;

3：类外初始化，即通过对象的引用进行初始化，这种方法一般用的最多，下面来看下实现过程：(注意私有的可通过setXX和getXX方法实现)

public static void main(String[] args) {
Person person = new Person();
person.name = "张三";
person.age = 14;
}

4:通过实例代码块和静态代码块进行初始化：这个在后面我们会专门讲到，在这里只需要知道这两个代码块的作用一般是提前初始化一些数据.

package Jiating;
public class Dog {
       String name; int age;
        float weight;
            public static void main(String[] args){
                Dog duoduo=new Dog();
                duoduo.name="多多";
                duoduo.age = 6;
                duoduo.weight =13.5f;
                Dog lucky=new Dog();
                lucky.name = "Lucky";
                lucky.age =3;
                lucky.weight =10.2f;
                System.out.println(duoduo.name + "今天" + duoduo.age +"岁了");
                System.out.println(lucky.name + "体重" + duoduo.weight +"千克");
    }
}

1-4 成员方法

成员方法就是对象所具有的动态功能。基本格式如下：

【访问修饰符】【修饰符】【返回值类型】【方法名称】【参数】【异常】【方法体】

访问修饰符：public（公共的）；protected（受保护的）；无修饰符和private（私有的）。

修饰符：对属性特征的描述：如static，final，abstract 等等。

返回值类型：方法返回数据的类型。

方法名称：任何合法标识符。

参数：可以有多个，使用逗号分隔。

异常：关键字：throws 【具体异常】

方法体：该方法具体实现功能的地方。

package IFather;
public class MethodSample01 {
    public String isOddNumber(int num){
        System.out.println("原始数据为："+num);
        if(num%2==0){
            return "偶数";
        }else{
            return "奇数";
        }
    }
    public static void main(String[] args) {
       /* int a=10;
        if(a%2==0){
            System.out.println(a+"是偶数 ");
        }else {
            System.out.println(a+"是奇数");
        }
        int b=5;
        if(b%2==0){
            System.out.println(b+"是偶数");
        }else{
            System.out.println(b+"是奇数");
        }*/
        //在mian使用方法，先创建对象才能使用
        int a=10;
        MethodSample01 methodSample01=new MethodSample01();
        String r1=methodSample01.isOddNumber(a);
        System.out.println(a+"是"+r1);
        int b=5;
        String r2=methodSample01.isOddNumber(b);
        System.out.println(b+"是"+r2);
    }
}

二、面向对象特性之封装

2-1 Package

Java 包(package)

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。

如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

package com.micheal.test
public class Test {
}

2-2 访问修饰量

修饰类，变量，方法时：

public公共，任何地方都能使用；

private私有，只能在类中使用；

不加修饰词=default，包内其他类可以用；

protected继承，只能继承的子类可以使用；

访问修饰符：public protected default private
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
public：对所有类可见。使用对象：类、接口、变量、方法
protected：对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private：在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
外部如何访问内部的私有成员变量适用本类中的共有方访问本类中的私有成员变量。

面向对象的三个基本特征是：封装、继承、多态。

package IFather;
public class PackageSample01 {
     //public代表其他任何类都能访问成员变量
    public String name;
    //private代表只能在当前类中使用
    private void sayHello(){
        System.out.println("Hello World");
    }
    //不写修饰符代表是默认修饰符，只能被包中其他类访问
    void sayGoodbye(){
        System.out.println("Good bye!");
    }
    public static void main(String[] args) {
        PackageSample01 packageSample01 = new PackageSample01();
        packageSample01.sayHello();
    }
}

2-3 面向对象封装

面型对象的三大特性：

封装解决了数据的安全性问题。

继承解决了代码的重用问题

多态解决了程序的扩展问题

封装：是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

也可以理解为：存在一个边界，边界之内的细节隐藏起来，只留下对外的借口(如：笔记本，手机，饮水机)

例如：笔记本如果不加塑料外壳能用不，能用，不过就是不安全，不好看罢了。而如果我们把它包装一下，我们用的功能多了吗？没有，不过比不包装不仅好看了，更重要的是安全了很多，也方便我们带了。

封装的好处：

① 只能通过规定方法访问数据，安全、易用、简单、易维护。

② 隐藏类的实现细节

③ 方便加入控制语句

④ 方便修改实现经过封装的属性，不能直接访问，要通过公共属性get/set方法访问。

2-4 对成员变量进行续写封装

对成员变量进行读写封装，是为了不允许用户修改某一些成员变量

对只允许读，不允许写的变量，只生成get方法，不生成set方法

public class MobileNumber {
    private String owner;
    private String areaCode;
    private String mobileNumber;
    //getter方法，用于读取成员变量的内容
    //getter书写格式，public 成员变量类型 get 成员变量名(),PS:首字母大写
    public String getOwner() {
        //this关键字代表当前对象的...
        return this.owner;
    }
    public String getAreaCode() {
        //this关键字代表当前对象的...
        return this.areaCode;
    }
    //setter方法，setter方法用于设置成员变量的内容
//setter书写格式：public void set成员变量名(新的数据参数)
    public void setOwner(String owner) {
        this.owner = owner;
    }
    public void setAreaCode(String areaCode) {
        this.areaCode = areaCode;
    }
}
 
public class MobileNumberTestor {
        public static void main(String[] args) {
            MobileNumber mobileNumber=new MobileNumber();
            mobileNumber.setOwner("老奇");
            String owner= mobileNumber.getOwner();
            System.out.println(owner);
            String areaCode=mobileNumber.getAreaCode();
            System.out.println(areaCode);
    }
}

三、面向对象特性之继承

3-1 面向对象继承

继承是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。面向对象技术中，继承关系是一种模仿现实世界中继承关系的一种类之间的关系，是超类（父类）和子类之间共享数据和方法的机制。父类定义公共的属性和操作，一个父类可以有多个子类，即多个特例。子类可以继承其父类或祖先类中的属性和操作作为自己的内容而不必自己定义，也可以覆盖这些操作，并加入新的内容。

继承：可以分单继承，多继承。

public class Mark1 {
    protected String title;
       protected String color;
       protected String movie;
       public void description(){
           System.out.println("型号:"+title);
           System.out.println("颜色:"+color);
           System.out.println("首次出现电影:"+movie);
       }
       private void fire(){
           System.out.println("利用手臂燃料泵射出火焰");
       }
       public static void main(String[] args) {
           Mark1 mark1=new Mark1();
           mark1.color="银灰色";
           mark1.movie="钢铁侠1";
           mark1.title="马克1型";
           mark1.description();
           mark1.fire();
       }
}

单继承
在默认情况下我们书写的一个Java类会自动继承Object类；如果使用”extends”关键字，我们也可以为它指定一个其它父类。那么，接下来的问题是“一个类可以指定几个父类呢”
在面向对象思维中只提到了有“继承”这种特性。但具体是“每个类可以同时继承多个父类（多继承）”还是“每个类只能有一个父类（单继承）”却并没有说明。所以现实当中，不同的面向对象的编程语言各有各的语法设计，而Java采用的是单继承。

package IFather;
 
public class Hulk extends Mark1{
    public static void main (String[] args) {
        Hulk hulk = new Hulk();
        hulk.title ="反浩克装甲";
        hulk.color = "红色";
        hulk.movie = "复仇者联盟3";
        hulk.description();
    }  
}

多继承

指一个子类同时继承多个父类，从而具备多个父类的特征

1、若子类继承的父类中拥有相同的成员变量，子类在引用该变量时将无法判别使用哪个父类的成员变量

2、若一个子类继承的多个父类拥有相同方法，同时子类并未覆盖该方法（若覆盖，则直接使用子类中该方法），那么调用该方法时将无法确定调用哪个父类的方法。

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

package IFather;
 
public class Mark85 extends Mark1{
    private void createShield() {
        System.out.println("利用纳米技术生成防御护盾");
    }
    public static void main(String[] args) {
        Mark85 mark85 = new Mark85();
        mark85.title ="马克85型";
        mark85.color ="红色";
        mark85.movie ="复仇者联盟4";
        mark85.description();
        mark85.createShield();
    }
 
}

四、面向对象特性之多态

4-1 面向对象多态

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。

多态是继封装、继承之后，面向对象的第三大特性。

多态现实意义理解：

1.现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

2.Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

3.多态体现为父类引用变量可以指向子类对象。

4.前提条件：必须有子父类关系。

编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。

多态存在的三个必要条件

继承关系

方法重写

父类引用指向子类对象

接口：是一个抽象的类型，只提供方法的定义

实现类：是一个借口的具体实现，要实现每一个接口方法的功能

一个多态拥有多个接口

interface Language {
    public void voice();
}
public class Chinese implements Language{
    @Override
    public void voice() {
        System.out.println("你好,有什么可以帮到你的?");
    }
}
public class English implements Language{
    @Override
    public void voice() {
        System.out.println("Hi,may I help you?");
    }  
}
public class French implements Language{
@Override
public void voice() {
    System.out.println("Comment puis-je me rendre a l'h pital");
    }
}
public class CustomerService {
    public static void main(String[] args) {
        Language language = new English();
        language.voice();
        Language languagel = new Chinese();
        languagel.voice();
        Language language2 = new French();
        language2.voice();
    }
}

4-2 ArrayList列表类的使用

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 ArrayList 继承了 AbstractList ，并实现了 List 接口。 ArrayList 类位于 java.util 包中，使用前需要引入它，

ArrayList类从AbstractList类继承而来，它实现了List接口。（集合接口由许多类实现，类实现了接口）ArrayList类是一个泛型类，声明为：class ArrayList<E>, 类型E指定了列表要保存的对象的类型。

ArrayList类实现了动态数组，可以根据需要增加或减小它的大小。

ArrayList类是一个特殊的数组--动态数组。来自于System.Collections命名空间；通过添加和删除元素，就可以动态改变数组的长度。

优点：

1、支持自动改变大小
2、可以灵活的插入元素
3、可以灵活的删除元素

package IFather;
 
import java.util.ArrayList;
import java.util.List;
public class ArrayListSample {
   public static void main(String[] args) {
     //泛型<类型>,用于规范列表中的数据
       List<String> bookList=new ArrayList<String>();//创建ArrayList对象
       bookList.add("红楼梦");//向列表末端追加数据
       bookList.add("西游记");
       bookList.add("水浒传");
       bookList.add("三国志");
       bookList.add("index:0，element“镜花缘");
       System.out.println(bookList);
       String bookName=bookList.get(2);//得到指定索引位置（从0开始）
       System.out.println(bookName);
       int size=bookList.size();//得到列表总数
       System.out.println(size);
       bookList.remove(2);
       bookList.remove(bookList.size()-1);
       System.out.println(bookList);
       for (String book:bookList){
           System.out.println("《"+book+"》");
       }
   }
}

Seal_heart_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java6、7章复习 5.4

一、面向对象编程的概念1-1 介绍类与对象类与对象的定义类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。 [1]类与对象的关系类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。类型的声明先声明类类型，然后再定义对象类的定...
复制链接

扫一扫