xiaoqiyan 的个人博客

记录精彩的程序人生

Open Source, Open Mind,
Open Sight, Open Future!
  menu
15 文章
0 评论
7238 浏览
0 当前访客
ღゝ◡╹)ノ❤️

Java学习之第3章 面向对象

第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 构造方法的定义

  1. 方法的名称和类必须相同
  2. 在方法名称前没有返回值类型的声明
  3. 在方法体中不可以使用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关键字

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

    package com.itheima.example05;
    
    public class Car {
        String color;
        public Car(String color){
            this.color = color;
        }
        public String getColor() {
            return this.color;
        }
    }
    
  2. 通过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 继承的概念

  1. 在java中类只支持单继承,不允许多重继承
  2. 多个类可以继承一个父类
  3. 多层继承是可以的

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关键字调用父类构造方法只能位于子类的第一行,且只能出现一次

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

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

评论
取消