菜鸡的Java学习笔记——类和对象

Java学习笔记——类和对象

什么是类和对象

类是抽象的概念，是对象的类型（模板），具有相同属性和方法的一组对象的集合；对象的属性，即为对象所具有的特征；对象的方法，即为对象执行的操作。

类描述对象的具体信息，而对象是一个具体实体。在java中，所有的java程序都以类class为组织单元

举个栗子，显示器是一个类，是一个抽象的概念，而我面前的显示器，实际存在的，则是一个对象，屏幕尺寸、刷新率、色域等是它的属性，而“显示画面”的功能可以作为它的方法。

Java中对于类的定义

步骤：

1. 定义类名
2. 编写类的属性——成员变量和方法
3. 编写类的方法

例子：编写手机类

public class Telphone {
    //属性（成员变量）：有什么
    float screen;//屏幕
    float CPU;//处理器
    float mem;//内存

    //方法：干什么
    void call()
    {
      System.out.print("Telphone可以打电话！");
    }//打电话
    void sendMessage()
    {
        System.out.println("Telphone可以发短信！");
    }//发短信
}

创建类的实例对象

//类名 对象名 = new 类名();
Telphone Iphone = new Telphone();
Telphone Huawei = new Telphone();

成员变量的使用

• 成员变量是隶属于某个对象的变量，用于保存对象的静态特征
• 同类型的不同对象拥有相同的成员变量，但值是独立的，要针对某个对象进行赋值

//对象名.成员变量=值;
public static void main(String[] args){
        Telphone Iphone = new Telphone();
        Iphone.screen=13.5f;
        Iphone.CPU=14f;
        Iphone.mem=16f;

        Telphone Huawei = new Telphone();
        Huawei.screen=14.5f;
        Huawei.CPU=13f;
        Huawei.mem=32f;
    }

f是为了保证数据类型为float，否则出错

方法（Method）

用于完成特定功能的整段代码，类似于C中的函数，区别在于Java中的方法需要在类中实现，以判断一个整数是奇数还是偶数的方法为例

1. 编写方法所属的类（MethodSample）
2. 编写方法的内容，注意返回类型以及参数类型
3. 在程序入口main()中使用方法，注意先实例化对象

public class MethodSample{
  public String isOddNumber(int num){
    if(num % 2 == 0)
      return "偶数";
    else
      return "奇数";
  }

  public static void main(String[] args){
    int a = 13;
    MethodSample Sample01 = new MethodSample();//实例化对象
    String ans = Sample01.isOddNumber(a);
    System.out.println(a + " is " + ans);
  }
}

包（Package）

• 把功能相似或相关的类组织在同一个包中
• 采用树形目录的存储方式，在文件目录中表现
• 可以通过包限定类的访问权限

命名规范

• 采用“逆域名法”进行命名，用.分割，单词小写
• 标准格式：域名后缀.组织机构名.项目名[.模块名].包的职能
• 例如com.alibaba.taobao(项目).customer(子模块).data
• 包中的类需要增加包的声明语句，idea自动生成

实例化其他包的类

• 需要使用import关键字导入其他包的类
• 例如在类PackageSample02中导入PackageSample01类
• 在同一个包下的类之间无需导入

package com.imooc.JavaCode.sample02;
//导入其他包的类
import com.imooc.JavaCode.sample01.PackageSample01;

public class PackageSample02 {
    public static void main(String[] args) {
        //实例化
        PackageSample01 packageSample01 = new PackageSample01();
    }
}

访问修饰符

• 用于控制类、成员变量、方法的访问范围

访问修饰符	名称	说明
private	私有	只能在类内部访问
public	公共	在任何地方都可以访问
(default)	默认	相同包的其他类可以访问
protected	继承	只有继承的子类可以访问

package com.imooc.JavaCode.sample01;

public class PackageSample01 {
    //任何地方都可以访问
    public String name;
    //只有这个类可以用
    private void SayHello() {
        System.out.println("Hello World!");
    }
    //只能被包中其他类访问
    void SayGoodbye(){
        System.out.println("Good bye!");
    }
}

面向对象三大特征

封装

• 隐藏功能的实现细节
• 利用对象与方法是实现封装的直接途径
• 良好的封装让代码更容易阅读与维护

使用者和提供者各自维护各自的代码，例如封装了一个排序算法，使用时只需调用，不需要考虑内部实现细节

package com.imooc.JavaCode.sample03;

public class Sorter {
    public static void main(String[] args) {
        Algorithm algorithm = new Algorithm();
        algorithm.sort(77, 99, 107, 33, 17);
    }
}

对成员变量进行读写封装

• 私有化成员变量
• 使用getter方法和setter方法对成员变量进行读写控制
• 例如在MobilNumber类中，owner是可以读写的，areaCode是可以读不可写的

package com.imooc.JavaCode.sample03;

public class MobileNumber {
    private String owner;//所有者
    
    private String areaCode = "86";//国家区号,不能写，只能读
    //只生成get方法，不生成set方法

    //读写
    //get方法用于读取成员变量的内容
    public String getOwner(){
        return this.owner;//this表示当前对象的owner
    }
    //set方法用于设置成员变量的内容
    public void setOwner(String owner){
        this.owner=owner;
    }

    //读
    public String getAreaCode(){
        return this.areaCode;
    }
}

继承

• extends关键字用于类的继承
• extends关键字后面是“父类”，extends关键字前是“子类”
• 子类会继承父类的（default）/protected/public修饰的成员变量与方法，private则不能访问
• 例如hulk类继承Mark1，私有的fire方法不能访问

在下面的例子，Hulk继承Mark1，Mark85继承Hulk

//Mark1类
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("手臂燃料");
    }

    //test
    public static void main(String[] args) {
        Mark1 mark1 = new Mark1();
        mark1.color = "银灰";
        mark1.movie = "IronMan I";
        mark1.title = "Mark I";
        mark1.description();
        mark1.fire();
    }

}

//Hulk类
public class Hulk extends Mark1{
    //特有方法
    private void repair(){
        System.out.println("替换战损部件！");
    }
    public static void main(String[] args) {
        Hulk hulk = new Hulk();
        //继承的成员变量和方法
        hulk.color = "Red";
        hulk.movie = "Avengers II";
        hulk.title = "反浩克装甲";
        hulk.description();
        //fire不能调用
        hulk.repair();
    }
}

//Mark85类
public class Mark85 extends Hulk{
    private void createShield(){
        System.out.println("生成防御护盾");
    }
    public static void main(String[] args) {
        Mark85 mark85 = new Mark85();
        mark85.color = "Red and Yellow";
        mark85.movie = "Avengers IV";
        mark85.title = "Mark85";
        mark85.description();

        mark85.createShield();
    }
}

多态

• 多态是同一个行为具有多个不同表现形式或形态的能力
• 实现多态的关键是接口
  • 接口（Interface）是一个抽象的类型，只提供方法的定义
  • 实现类是一个接口的具体实现，要实现每一个接口方法的功能

例如在一个电话问候语系统中，要根据来电的区号选择合适的语言，接口为语言（Language），实现类是各种不同语言的问候语

接口中不允许有方法体，仅允许有方法定义

public interface Language {
    public void voice();
    //各国语言方法定义
}

各实现类实现方法体

public class English implements Language{
    @Override
    public void voice() {
        System.out.println("Hello!");
    }
}

public class Chinese implements Language{
    @Override
    public void voice() {
        System.out.println("您好!");
    }
}

public class French implements Language{
    @Override
    public void voice() {
        System.out.println("Bonjour!");
    }
}

问候系统

public class CustomerService {
    //返回类型为接口，返回接口的实现类
    public Language contact(int areaCode){
        if(areaCode == 86)
            return new Chinese();
        else if(areaCode == 33)
            return new French();
        else
            return new English();
    }

    //也可以在其他包中的类调用
    public static void main(String[] args) {
        CustomerService customerService = new CustomerService();
        Language language = customerService.contact(33);
        language.voice();
    }
}
//运行结果是Bonjour!

ArrayList类的使用

• ArrayList是Java内置的数据集合，用于存储多个数据
• 是数组替代品，提供了更多数据操作方法，几乎是每一个项目中必用的类

插入、查询、删除、遍历、查询长度几种操作

import java.util.List;
import java.util.ArrayList;

public class ArrayListSample {
    public static void main(String[] args) {
        //字符串类型数据(泛型)
        List<String> bookList = new ArrayList<String>();

        //尾部插入
        bookList.add("红楼梦");
        bookList.add("西游记");
        bookList.add("水浒传");
        bookList.add("三国演义");
        System.out.println(bookList);

        //头部插入
        bookList.add(0,"大学物理");
        System.out.println(bookList);

        //按索引查询
        String TheThirdBookName = bookList.get(2);
        System.out.println(TheThirdBookName);

        //大小
        int size = bookList.size();
        System.out.println(size);

        //按索引删除
        bookList.remove(2);
        System.out.println(bookList);

        //删除最后一个(组合应用)
        bookList.remove(bookList.size()-1);
        System.out.println(bookList);

        //遍历
        for(String book : bookList){
            System.out.println("《" + book + "》");
        }
    }
}

运行结果

——《慕课网》