Java面向对象3

1269-郑同学

发表文章数:16

热门标签

首页 » Java » 正文

面向对象

final关键字

final是一个关键字,表示最终的意思,可以用来修饰类、变量和方法。

修饰类:表明该类是最终类,不能被继承
修饰变量:表明该变量是常量,不能再次被赋值
修饰方法:表明该方法是最终方法,不能被重写

//public final class Father {}

public class Father {
    public final void method() {
        System.out.println("method father");
    }
}
public class Son extends Father {
    public final int age = 20;

    public void show() {
        //age = 10;
        System.out.println(age);
    }

    /*
    @Override
    public void method() {
        System.out.println("method son");
    }
    //报错
     */
}

static关键字

static是一个关键字,表示静态的意思,可以用来修饰成员变量和成员方法

static修饰成员的特点

  • 被类的所有对象共享
    也是判断一个成员是否应该用static修饰的条件
  • 可以通过类名直接访问
  • 优先于对象存在
  • 随着类的加载而加载
public class Student {
    public String name;
    public int age;
    //public String graduateFrom; //毕业院校
    public static String graduateFrom; //毕业院校

    public void show() {
        System.out.println("name"+"---"+age+"---"+graduateFrom);
    }
}
public class Static {
    public static void main(String[] args) {
        Student.graduateFrom = "传智学院";

        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        //s1.graduateFrom = "传智学院";
        s1.show();

        Student s2 = new Student();
        s2.name = "刘德华";
        s2.age = 28;
        //s2.graduateFrom = "传智学院";
        //当用static修饰graduateFrom后,毕业院校从null变成传智学院
        s2.show();
    }
}

static方法的访问特点及注意事项

非静态的成员方法能访问:静态的成员变量、非静态的成员变量、静态的成员方法、非静态的成员方法
静态的成员方法能访问:静态的成员变量、静态的成员方法

注意事项:

  • 静态方法中不能出现this,super这样的关键字
  • 因为static随着类的加载而加载,而this,super随着对象的创建而存在,先进内存的不能访问后进内存的
public class Student {
    //非静态的成员变量
    private String name = "林青霞";
    //静态的成员变量
    private static int age = 30;

    //非静态的成员方法
    public void show() {
        this.name = "刘德华";
        System.out.println(name);
        System.out.println(age);
        show2();
        show4();
    }

    public void show2() {}

    //静态的成员方法
    public static void show3() {
        //this.age
        //this.name
        
        //System.out.println(name); //报错
        System.out.println(age);
        //show2(); //报错
        show4();
    }

    public static void show4() {}
}

抽象类

在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。

public abstract class Animal {
    /*
    public void eat() {
        System.out.println("吃东西");
    }
     */

    public abstract void eat();
}
public class AnimalDemo {
    public static void main(String[] args) {
        /*
        Animal a = new Animal();
        a.eat();
        Animal变成抽象类,就不能创建对象了
         */
    }
}

抽象类的特点

  1. 抽象类和抽象方法必须使用abstract关键字修饰
  2. 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
  3. 抽象类不能直接实例化
    抽象类可以参照多态的方式,通过子类对象实例化
  4. 抽象类的子类
    要么重写抽象类中的所有抽象方法
    要么是抽象类
public abstract class Animal {
    //抽象方法
    public abstract void eat();

    public void sleep() {
        System.out.println("睡觉");
    }
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public abstract class Dog extends Animal {
}
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象
        //Animal a = new Animal();
        //按照多态的形式实例化抽象类
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

抽象类的成员特点

  • 成员变量
    有成员变量,成员变量可以是变量也可以是常量,
  • 构造方法
    有构造方法
    抽象类中构造方法的作用:用于子类访问父类数据的初始化
  • 成员方法
    有成员方法,成员方法可以是抽象的也可以是非抽象的
    抽象方法:限定子类必须完成某些动作
    非抽象方法:提高代码的复用性
public abstract class Person {
    private int age = 20;
    private final String country = "中国";

    public Person() {}

    public Person(int age) {
        this.age = age;
    }

    public void show() {
        age = 30;
        System.out.println(age);
        //country = "美国";
        System.out.println(country);
    }

    public abstract void eat();
}
public class Student extends Person {

    @Override
    public void eat() {
        System.out.println("学生吃米饭");
    }
}
public class PersonDemo {
    public static void main(String[] args) {
        Person p = new Student();
        p.show();
    }
}

练习

分析:从具体到抽象
实现:从抽象到具体
使用:使用的是具体的类的对象

分析:

基础班老师:
		成员变量:name,age
		构造方法:无参,带参
		成员方法:getxxx(),setxxx(),teach(){}
就业班老师:
		成员变量:name,age
		构造方法:无参,带参
		成员方法:getxxx(),setxxx(),teach(){}

抽象的老师类:
		成员变量:name,age
		构造方法:无参,带参
		成员方法:getxxx(),setxxx(),teach();
public abstract class Teacher {
    private String name;
    private int age;

    public Teacher() {}

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void teach();
}
public class BacisTeacher extends Teacher {

    public BacisTeacher() {}

    public BacisTeacher(String name, int age) {
        super(name,age);
    }

    @Override
    public void teach() {
        System.out.println("基础班老师讲解JavaSE的内容");
    }
}
public class WorkTeacher extends Teacher {

    public WorkTeacher() {}

    public WorkTeacher(String name, int age) {
        super(name,age);
    }

    @Override
    public void teach() {
        System.out.println("就业班老师讲解JavaEE的内容");
    }
}
public class TeacherDemo {
    public static void main(String[] args) {
        Teacher t1 = new BacisTeacher();
        t1.setName("林青霞");
        t1.setAge(30);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.teach();

        Teacher t2 = new WorkTeacher("林青霞",30);
        System.out.println(t2.getName()+"---"+t2.getAge());
        t2.teach();
    }
}

接口

为了体现事物功能的扩展性,Java就提供了接口来定义这些额外功能,并不给出具体实现(抽象的)。

接口的特点

  1. 定义接口使用的是interface关键字
  2. 类和接口之间是实现关系,用implements关键字表示
  3. 接口本身不能实例化
    可以参照多态的形式使用实现类来实例化
  4. 接口的实现类
    要么重写接口中的所有抽象方法
    要么是一个抽象类

多态的几种形式:

  • 具体类多态(几乎不用)
  • 抽象类多态(常用)
  • 接口多态(最常用)
public interface Jumpping {
    //抽象方法
    public abstract void jump();
}
public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public abstract class Dog implements Jumpping {
}
public class InterfaceDemo {
    public static void main(String[] args) {
        //Jumpping j = new Jumpping();
        //接口多态的形式实例化
        Jumpping j = new Cat();
        j.jump();
    }
}

接口的成员特点

  • 成员变量
    有成员变量,而且变量只能是常量
    默认修饰符:public static final
  • 构造方法
    没有构造方法
  • 成员方法
    有成员方法,而且都是抽象的
    默认修饰符:public abstract

Object:是类层次结构的根类,所有的类都直接地或间接地继承自该类

public interface Inter {
    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;

    //public Inter() {}

    //public void show() {}
    public abstract void method();
}
//public class InterImpl implements Inter
public class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }

    @Override
    public void method() {

    }
}
public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        //i.num = 40; //接口中的变量默认是常量
        System.out.println(i.num);
        //i.num2 = 40;
        System.out.println(i.num2);
        //接口成员变量是静态修饰的
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
    }
}

类与类,类与接口以及接口与接口的关系

类与类

  • 继承关系,只能单继承,可以多层继承。

类与接口

  • 实现关系,可以单实现,也可以多实现
  • 还可以再继承一个类的同时实现多个接口
public class Son extends Object implements Father, Mother {
}

接口与接口

  • 继承关系,可以单继承,也可以多继承
public interface Sister extends Father, Mother {
}

抽象类和接口的区别

  1. 成员区别:
    抽象类:
    成员变量:可以是变量,也可以是常量
    构造方法:有
    成员方法:可以是抽象方法,也可以是非抽象方法
    接口:
    成员变量:只能是常量
    成员方法:只能是抽象方法
  2. 关系区别
    类与类:继承关系,只能单继承,可以多层继承
    类与接口:实现关系,可以单实现,也可以多实现
    接口与接口:继承关系,可以单继承,也可以多继承
  3. 设计理念的区别
    抽象类 被继承体现的是:“is a”,抽象类中定义的是继承体系的共性功能
    接口 被实现体现的是:“like a”,接口中定义的是该体系的扩展功能
    举例:
    猫,动物
    猫,跳高运动员

练习

练习1 猫狗案例

需求:让所有的猫狗具备跳高的额外功能

分析:从具体到抽象
猫:姓名,年龄,吃饭(){}
狗:姓名,年龄,吃饭(){}
发现了共性的内容,就提取一个父类
抽象动物类:姓名,年龄,吃饭();
猫:继承动物类
狗:继承动物类

跳高的额外功能是一个扩展功能,所以应该定义接口实现
跳高接口:跳高();
猫:继承动物类,实现跳高接口
狗:继承动物类,实现跳高接口

实现:从抽象到具体
使用:使用的是具体的类的对象
public interface Jumpping {
    public abstract void jump();
}
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {}

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}
public class Cat extends Animal implements Jumpping {
    public Cat() {}

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}
public class Dog extends Animal implements Jumpping {
    public Dog() {}

    public Dog(String name, int age) {
        super(name,age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void jump() {
        System.out.println("狗跳高");
    }
}
public class InterfaceTest {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("加菲猫");
        c.setAge(3);
        System.out.println(c.getName()+"---"+c.getAge());
        c.eat();
        c.jump();

        Cat c2 = new Cat("加菲猫",3);
        System.out.println(c2.getName()+"---"+c2.getAge());
        c2.eat();
        c2.jump();
    }
}

练习2 运动员与教练案例

需求:
乒乓球运动员和篮球运动员
乒乓球教练和篮球教练
为了出国交流,跟乒乓球相关的人也都需要学习英语

分析:从具体到抽象。分析抽象类,接口,具体类

具体类:
乒乓球运动员:姓名,年龄,学习(){}
篮球运动员:姓名,年龄,学习(){}
乒乓球教练:姓名,年龄,教(){}
篮球教练:姓名,年龄,教(){}

抽象类:
发现了共性的内容,提取父类
抽象运动员类:姓名,年龄,学习();
抽象教练类:姓名,年龄,教();
抽象人类:姓名,年龄,吃饭();
运动员:继承人类
教练:继承人类
乒乓球运动员:继承运动员类
篮球运动员:继承运动员类
乒乓球教练:继承教练类
篮球教练:继承教练类

接口:

英语的额外功能是一个扩展功能,所以应该定义接口实现
英语接口:英语();
乒乓球运动员:继承运动员类,实现英语接口
篮球运动员:继承运动员类
乒乓球教练:继承教练类,实现英语接口
篮球教练:继承教练类

实现:从抽象到具体
接口

public interface SpeakEnglish {
    public abstract void speak();
}

抽象类

public abstract class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}
public abstract class Player extends Person {
    public Player() {}

    public Player(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}
public abstract class Coach extends Person {
    public Coach() {}

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

具体类

public class PingPangPlayer extends Player implements SpeakEnglish {
    public PingPangPlayer () {}

    public PingPangPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜,喝小米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}
public class BasketballPlayer extends Player {
    public BasketballPlayer() {}

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学习运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉,喝牛奶");
    }
}
public class PingPangCoach extends Coach implements SpeakEnglish {
    public PingPangCoach() {}

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜,喝大米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}
public class BasketballCoach extends Coach {
    public BasketballCoach() {}

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练教吃羊肉,喝羊奶");
    }
}

使用:使用的是具体的类的对象

public class Test {
    public static void main(String[] args) {
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("王浩");
        ppp.setAge(30);
        System.out.println(ppp.getName()+"---"+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();

        PingPangPlayer ppp2 = new PingPangPlayer("王浩",30);
        System.out.println(ppp2.getName()+"---"+ppp2.getAge());
        ppp2.eat();
        ppp2.study();
        ppp2.speak();

        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("姚明");
        bp.setAge(30);
        System.out.println(bp.getName()+"---"+bp.getAge());
        bp.eat();
        bp.study();

        BasketballPlayer bp2 = new BasketballPlayer("姚明",30);
        System.out.println(bp2.getName()+"---"+bp2.getAge());
        bp2.eat();
        bp2.study();
    }
}

包:其实就是文件夹
作用:对类进行分类管理

举例:
学生:增加,删除,修改,查询
老师:增加,删除,修改,查询
……
分包方案1:按功能分

add
	AddStudent
	AddTeacher
delete
	DeleteStudent
	DeleteStudent
……

分包方案2:按模块分

student
	AddStudent
	DeleteStudent
	……
teacher
	AddTeacher
	DeleteTeacher
	……

包的定义格式:
package 包名;
如果是多级包用.隔开即可

注意事项:

  1. package必须是程序的第一条可执行语句
  2. package语句在一个java文件中只能有一个

导包

类在不同一个包下,使用的时候,要加类的全路径名称

	cn.itcast.Teacher t = new cn.itcast.Teacher();

导包:
格式: import 包名;

	import cn.itcast.Teacher;

权限修饰符

				本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private:		Y				
默认:			Y		Y
protected:		Y		Y							Y
public:		Y		Y							Y				Y

本类:

public class Father {
    private void show() {
        System.out.println("show");
    }

    void show2() {
        System.out.println("show2");
    }

    protected void show3() {
        System.out.println("show3");
    }

    public void show4() {
        System.out.println("show4");
    }

    public static void main(String[] args) {
        Father f = new Father();
        f.show();
        f.show2();
        f.show3();
        f.show4();
    }
}

同一个包下(子类和无关类)

public class Son extends Father {
    public static void main(String[] args) {
        Father f = new Father();
        //f.show(); //报错
        f.show2();
        f.show3();
        f.show4();

        Son s = new Son();
        s.show2();
        s.show3();
        s.show4();
    }
}
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        //f.show(); //报错
        f.show2();
        f.show3();
        f.show4();
    }
}

不同包下(子类)

public class Son extends Father {
    public static void main(String[] args) {
        Father f = new Father();
        //f.show();
        //f.show2();
        //f.show3();
        f.show4();

        Son s = new Son();
        //s.show2();
        s.show3();
        s.show4();
    }
}

不同包下(无关类)

public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        //f.show();
        //f.show2();
        //f.show3();
        f.show4();
    }
}
标签:

拜师教育学员文章:作者:1269-郑同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《Java面向对象3》 发布于2020-09-09

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录