Java学习之第3章面向对象

2022-01-18/2022-01-18 / Java

第3章面向对象

第3章面向对象
- 3.1 面向对象的概念和特征
- 3.2 类和对象
  - 3.2.1类和对象的关系
  - 3.2.2类的定义
  - 3.2.3对象的创建
- 3.3 构造方法
  - 3.3.1 构造方法的定义
  - 3.3.2 构造方法的重载
- 3.4 this关键字
- 3.5 static 关键字
  - 3.5.2 静态方法
- 3.6 类的继承
  - 3.6.1 继承的概念
  - 3.6.2 重写父类方法
  - 3.6.3 super关键字
- 3.7 抽象类和接口
  - 3.7.1 抽象类
  - 3.7.2 接口
- 3.8 多态
  - 3.8.1 多态概述
  - 3.8.2 对象的类型转换
  - 3.8.3 匿名内部类
- 3.9 异常
  - 3.9.1 异常的概念
  - 3.9.4 throws关键字
- 3.10 访问控制

3.1 面向对象的概念和特征

1.封装性：将对象的属性和行为封装起来，不需要让外界知道是怎么实现的

2.继承性：描述类和类之间的关系

3.多态性：对象在不同情况下具有不同的表现能力

3.2 类和对象

3.2.1类和对象的关系

类是一组具有共同特征和行为的对象的抽象描述

对象是该类事物的具体个体

3.2.2类的定义

package com.itheima.example01;

public class Car{
    String color;
    int num;
    public void run() {
        System.out.println("这辆车的颜色是"+color+",轮胎的数量是:"+num);
    }
}

3.2.3对象的创建

package com.itheima.example01;

public class Example01 {
    public static void main(String[] args) {
        Car c1 = new Car();
        Car c2 = new Car();
        c1.color="red";
        c1.num=4;
        c1.run();
        c2.run();
    }
}

3.2.4 类的封装

定义一个类是将类中的属性进行私有化，使用private关键字进行修饰

package com.itheima.example02;

public class Car {
    private String color;
    private int num;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int carNum) {
        if (carNum !=4){
            System.out.println("输入的轮胎数量不正确");
        }else {
            num=carNum;
        }
    }
    public void run() {
        System.out.println("这辆车的颜色是"+color+",轮胎的数量是:"+num);
    }
}

package com.itheima.example02;

public class Example02 {
    public static void main(String[] args) {
        Car c = new Car();
        c.setNum(-1);
        c.setColor("red");
        c.run();
    }
}

3.3 构造方法

3.3.1 构造方法的定义

方法的名称和类必须相同
在方法名称前没有返回值类型的声明
在方法体中不可以使用return语句返回一个值，犯允许单独写return语句作为方法的结束

package com.itheima.example03;

public class Car {
    public Car() {
        System.out.println("无参数的构造方法执行了..");
    }
}

package com.itheima.example03;

public class Example03 {
    public static void main(String[] args) {
        Car c =new Car();
    }
}

3.3.2 构造方法的重载

package com.itheima.example05;

public class Car {
    String color;
    int num;
    public Car(String c_color,int c_num){
        color = c_color;
        num = c_num;
    }
    public Car(String c_color){
        color = c_color;
    }
    public void run() {
        System.out.println("这辆车的颜色是"+color+",轮胎数量是"+num);
    }
}

package com.itheima.example05;

public class Example05 {
    public static void main(String[] args) {
        Car c1 = new Car("red");
        Car c2 = new Car("blue",4);
        c1.run();
        c2.run();
    }
}

3.4 this关键字

通过this关键字可以明确地访问一个类的成员变量，解决与局部变量名称相同的问题

package com.itheima.example05;

public class Car {
    String color;
    public Car(String color){
        this.color = color;
    }
    public String getColor() {
        return this.color;
    }
}

通过this关键字调用成员方法

package com.itheima.example05;

public class Car {
    
    public void show(){

    }
    public void run(){
        this.show();
    }
}

3.5 static 关键字

如果有些属性希望被所有对象共享，就必须使用static关键字修饰成员变量，这就是静态变量

package com.itheima.example07;

public class Car {
    static String carName="大众";
}

package com.itheima.example07;

public class Example07 {
    public static void main(String[] args) {
        Car c1 = new Car();
        Car.carName="大众";
        System.out.println("这辆车的厂商是:"+Car.carName);
        System.out.println("这辆车的厂商是:"+c1.carName);

    }
}

注意：static关键字只能用于修饰成员变量,不能用于修饰局部变量,否则编译会报错

3.5.2 静态方法

package com.itheima.example08;

public class Car {
    public static void run() {
        System.out.println("run()方法被执行了...");
    }
}

package com.itheima.example08;

public class Example08 {
    public static void main(String[] args) {
        Car.run();//类名.方法的方式调用
        Car c =new Car();
        c.run();//实例化对象的方式调用静态方法
    }
}

3.6 类的继承

3.6.1 继承的概念

在java中类只支持单继承，不允许多重继承
多个类可以继承一个父类
多层继承是可以的

3.6.2 重写父类方法

子类在重写的方法必须与父类被重写的方法具有相同的方法名、参数列表以及返回值类型

package com.itheima.example10;

public class Animal{
    public void call(){
        System.out.println("动物发出声音...");
    }
    public void sleep(){
        System.out.println("动物在睡觉");
    }
}

package com.itheima.example10;

public class Cow extends Animal{
    public void call(){
        System.out.println("哞...");
    }
}

package com.itheima.example10;

public class Example10 {
    public static void main(String[] args) {
        Cow c = new Cow();
        c.call();
        c.sleep();
    }
}

3.6.3 super关键字

当子类重写父类方法后，子类对象就不能访问父类被重写的方法，这时候就要使用super关键字

super.成员变量

super.成员方法

super()//访问构造方法

package com.itheima.example11;

public class Animal {
    public Animal(String name) {
        System.out.println("我是一头"+name);
    }
}

package com.itheima.example11;

class Cow extends Animal{
    public Cow() {
        super("黄牛");
    }
}

package com.itheima.example11;

public class Example11 {
    public static void main(String[] args) {
        Cow c = new Cow();
    }
    
}

注意：super关键字调用父类构造方法只能位于子类的第一行，且只能出现一次

final关键字

final修饰的类不能被继承

final修饰的方法不能被子类重写

final修饰的变量是常量，并且只能赋值一次

3.7 抽象类和接口

3.7.1 抽象类

使用abstract修饰

package com.itheima.example12;

public abstract class Animal {
    abstract void call();
}

package com.itheima.example12;

public class Cow extends Animal{
    void call(){
        System.out.println("哞...");
    }
}

package com.itheima.example12;

public class Example12 {
    public static void main(String[] args) {
        Cow c =new Cow();
        c.call();
    }
}

3.7.2 接口

在接口中只存在常量和抽象方法，不存在变量的定义和方法实现

package com.itheima.example13;

/**
 * Animal
 */
interface Animal {
    String ANIMAL_ACTION="动物的行为动作";
    void call();
    
}

package com.itheima.example13;

class Cow implements Animal{
    public void call(){
        System.out.println(ANIMAL_ACTION+":"+"哞...");
    }
}

package com.itheima.example13;

public class Example13 {
    public static void main(String[] args) {
        Cow c = new Cow();
        c.call();
    }
}

接口的访问限定只有public和默认。
允许接口的多重继承,通过“extends父接口名”的形式可以继承多个接口,接口之间用逗号(,)隔开。
在接口中定义的常量,系统默认为是public static final修饰的,不需要指定。
在接口中声明的方法,系统默认为是public abstract修饰的。
接口中的方法都是抽象的,不能实例化对象。

3.8 多态

3.8.1 多态概述

在同一个方法中，参数类型不同而出现执行效果各异的现象

package com.itheima.example14;

interface Animal{
    void call();
}

package com.itheima.example14;

interface Animal{
    void call();
}

package com.itheima.example14;

public class Sheep implements Animal{
    public void call(){
        System.out.println("咩..");
    }
}

package com.itheima.example14;

public class Example14 {
    public static void main(String[] args) {
        Animal a1=new Cow();
        Animal a2=new Sheep();
        animalCall(a1);
        animalCall(a2);
    }

    public static void animalCall(Animal a) {
        a.call();
    }
}

3.8.2 对象的类型转换

package com.itheima.example14;

interface Animal{
    void call();
}

package com.itheima.example14;

interface Animal{
    void call();
}

package com.itheima.example14;

public class Sheep implements Animal{
    public void call(){
        System.out.println("咩..");
    }
}

package com.itheima.example15;

public class Example14 {
    public static void main(String[] args) {
        Sheep s=new Sheep();
        animalCall(s);
    }

    public static void animalCall(Animal a) {
        if (a instanceof Cow){
            Cow c =(Cow)a;
            c.call();
        }else{
            System.out.println("这个动物不是牛!");
        }
        
    }
}

3.8.3 匿名内部类

格式

new 父类(参数列表)或父接口(){
	//实现
}

package com.itheima.example16;

interface Animal{
    void call();
}

package com.itheima.example16;

public class Example16 {
    public static void main(String[] args) {
        animalCall(new Animal(){
            public void call() {
                System.out.println("哞...");
            }
        });
    }
    public static void animalCall(Animal a){
        a.call();
    }
}

3.9 异常

3.9.1 异常的概念

package com.itheima.example18;

public class Example18 {
    public static void main(String[] args) {
        try {
            int res =calculate(5,1);
            System.out.println(res);
        }catch (Exception e) {
            System.out.println("捕获的异常是:"+e.getMessage());
            return;
        }finally {
            System.out.println("finally代码块");
        }
        System.out.println("程序代码继续执行");
    }
    public static int calculate(int a, int b){
        int res = a/b;
        return res;
    }
}

3.9.4 throws关键字

package com.itheima.example19;

public class Example19 {
    public static void main(String[] args) throws Exception {
        int res= calculate(6,3);
        System.out.println(res);
    }
    public static int calculate(int a,int b)throws Exception{
        int res = a/b;
        return res;
    }
}

3.10 访问控制

控制级别：public>protected>default>private

private(类访问级别):表示私有的,使用private修饰的成员只能被该类的其他成员访问,其他类无法直接访问。

default(包访问级别):若没有访问修饰符,则系统默认使用default。该类可以被本类包中的所有类访问。

protected(子类访问级别):表示受保护的,该类可以被同一包下的其他类访问,也能被不同包下的子类访问。

public(公共访问级别):表示公有的,该类或者类中的成员可以被所有的类访问。

标题：Python
作者：肖祺彦
地址：url