Java面对对象(下) – 2

1.final关键字

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

	final修饰类：表明该类是最终类，不能被继承；
	final修饰变量：表明该变量是常量；
	final修饰方法：表明该方法是最终方法，不能被重写

2.static关键字

静态成员变量的特点：

static：是一个关键字，静态的意思。可以用来用来修饰成员变量和成员方法。
	a:static修饰成员变量：被类的所有对象共享
					 其实也是判断一个成员是否应该用static修饰的条件
	
	b:可以通过类名直接访问；
	c:优先于对象存在；
	d:随着类的加载而加载；

静态方法的的访问特点以及注意事项：

非静态的成员方法：
	能访问静态的成员变量；
	能访问非静态的成员变量；
	能访问静态成员方法；
	能访问非静态的成员方法；
	
静态的成员方法：
	能访问静态的成员变量；
	能访问静态的成员方法；

注意事项：静态成员方法中不能出现this,super这样的关键字
原因：静态是随着类的加载而加载，this,super这样的关键字是随着对象的创建而存在
	 先进内存的，不能访问后进内存的。

3.抽象类

抽象类概述：

动物类中应该没出一个声明，在Java中一个没有方法体的方法应该被定义为抽象方法，
而类中如果有抽象方法，那么该类必须定义为抽象类。

*Java中要么有方法体，要么是抽象方法；
*抽象方法必须在抽象类中实现；

public abstract class Animal {	
	public abstract void eat();		# Java中要么有方法体，要么是抽象方法；
}

抽象类的特点：

1.抽象类和抽象方法必须使用abstract关键字来修饰；

2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类；

3.抽象类不能实例化；
	抽象类如何实例化？
	参照多态的方式，通过子类对象实例化。
	
4.抽象类的子类
		要么重写抽象父类中的所有抽象方法；
		要么是抽象类；

抽象类的成员特点：

抽象类中成员的特点：
	成员变量：
		有成员变量，成员变量可以是变量，也可以是常量；
		
	构造方法：
		有构造方法
		抽象类中构造方法的作用？
			用于子类访问父类数据的初始化；
			
	成员方法：
		有成员方法，可以是抽象，也可以是非抽象的；
		抽象方法：限定子类必须完成某些动作；
		非抽象方法：提高代码的复用性；

抽象类的练习：

写代码的过程：
	分析：从具体到抽象；
	实现：从抽象到具体；
	使用：使用的是具体类的对象；

分析：
	基础班老师：
		成员变量：name,age
		构造方法：无参，有参
		成员方法：getXxx(),setXxx(),teach(){}
	就业班老师：
		成员变量：name,age
		构造方法：无参，带参
		成员方法：getXxx(),setXxx(),teach(){}
	
	抽象的老师类：
		成员变量：name,age;
		构造方法：无参，有参；
		成员方法：getXxx(),setXxx(),teach();

package com.scy;		//抽象父类Teacher

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();
}

package com.scy;		// 子类BasicTeacher

public class BasicTeacher extends Teacher{

    public BasicTeacher(){}

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

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

package com.scy;	//子类WorkTeacher

public class WorkTeacher extends Teacher {
    public WorkTeacher(){}

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

    @Override
    public void teach() {
        System.out.println("就业班老师讲解JAVAEE的内容");
    }
}

package com.scy;	// 测试类

public class TeacherDemo {
    public static void main(String[] args) {
        // 使用的是具体的类的对象

        //多态形式的测试
        Teacher t = new BasicTeacher("wang",35);
        System.out.println(t.getName()+"-----"+t.getAge());
        t.teach();

        t = new BasicTeacher();
        t.setName("liu");
        t.setAge(50);
        System.out.println(t.getName()+"-----"+t.getAge());
        t.teach();
    }
}

4.接口

接口的概述：

例如一些动物本身不具备的一些能力，但是可以通过后天训练得到的能力（猫钻火圈，狗熊拜年等）
这些额外的动作定义到动物类中就不合适，也不合适定义到猫/狗熊类中。为了体现事物功能的扩展性，
Java就提供了接口来定义这些额外功能。（增加了代码的扩展性）

public interface Jumpping{
	// 抽象方法
	public abstract void jump();
	
}

public class Cat implements Jumpping{
	@Override
	public void jump(){
		System.out.println("猫可以跳高");
	}
}

public class InterfaceDemo {	//测试类
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.jump();
    }
}

1.定义接口使用的是interface关键字
2.类于接口之间的实现关系，用implement关键字表示；
3.接口不能实例化：
	接口有没有其他的方式实例化呢？
	参照多态的形式使用显现类来实例化；
4.接口实现类
	要么重写接口中的所有抽象方法
	要么是个抽象类

接口的特点：

成员变量：
	有成员变量，而且变量只能是常量
	默认修饰符：public static final
构造方法：
	无构造方法；
成员方法：
	有成员方法：而且都是抽象的；
	默认修饰符：public abstract
	
Object:是类的层次结构的根类，所有类都直接或者间接的继承该类；

类于类/类于接口/接口与接口的关系

类与类的关系：
	继承关系：只能单继承，可以多层继承。
	
	类与接口：实现关系，可以单实现也可以多实现。
	
	接口与接口：继承关系，可以单继承，也可以多继承

抽象类与接口的区别

抽象类与接口的区别
1.成员区别：
		抽象类：
			成员变量：可以是变量，也可以是常量
			构造方法：有
			成员方法：可以是抽象方法，也可以是非抽象方法
		接口：
			成员变量：只能是常量
			构造方法：无
			成员方法：只能是抽象方法

2.关系区别：
	类与类：继承关系，只能单继承，可以多层继承
	类与接口：实现关系，可以单实现也可以多实现。
	接口与接口：继承关系，可以单继承，也可以多继承
3.设计理念的区别：
	抽象类 被继承体现的是：“is a”  抽象类中定义的是继承体系的共性功能
	接口 被实现体现的是：“like a”  接口是定义该体系的扩展功能

接口练习

练习1

需求：猫狗案例，让所有的猫狗具备调高的额外功能

package com.scy;	//调高接口

public interface Jumpping {
    public abstract void jump();
}

package com.scy;	// 抽象父类Animal

public abstract class  Animal {
    private String name;
    private int age;
    public Animal(){}

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

    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();
}

package com.scy;		//子类Cat

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("猫跳高");
    }
}

package com.scy;	// 测试类

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

练习2

需求：乒乓球运动员和篮球运动员
	 乒乓球教练和篮球教练
	 为了出国交流，跟乒乓球相关的人员都需要学习英语
		
			分析：有哪些抽象类，哪些接口，哪些具体类

package com.scy08;		//说英语的接口SpeakEnglish

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

package com.scy08;	//抽象类父类Person

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

    Person(){}
    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();
}

package com.scy08;	//抽象类父类Coach继承Person

public abstract class Coach  extends Person{
    public Coach() {}
    public Coach(String name, int age){
        super(name, age);
    }

    public abstract void teach();
}

package com.scy08; 	//抽象类父类Player继承Person

public abstract class Player extends Person {
    public Player(){}
    public Player(String name, int age){
        super(name,age);
    }

    public abstract void study();
}

package com.scy08;	//子类BasketballCoach继承于Coach

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

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

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

package com.scy08;	//子类PingPongCoach 继承于Coach并实现SpeakEnglish接口

public class PingPongCoach extends Coach implements SpeakEnglish {

    PingPongCoach(){}
    PingPongCoach(String name,int age){
        super(name, age);
    }

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

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

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练说英语");
    }
}

package com.scy08;	// 子类BasketballlPlayer继承于Player

public class BasketballlPlayer extends Player  {

    BasketballlPlayer(){}

    BasketballlPlayer(String name, int age){
        super(name, age);
    }

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

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉喝牛奶");
    }
}

package com.scy08;	// 子类PingPangPlayer 继承于Player实现SpeakEnglish接口

public class PingPangPlayer extends Player implements SpeakEnglish {

    PingPangPlayer(){}

    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 speakEnglish() {
        System.out.println("乒乓球运动员说英语");
    }
}

package com.scy08;

public class InterfaceTest {
    public static void main(String[] args) {
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("李白");
        ppp.setAge(50);
        System.out.println(ppp.getName()+"---"+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speakEnglish();
    }
}

5.多态的几种形式

具体类多态：（几乎不用）
抽象类多态：（常用）
接口多态：（最常用）

6.包和导包

包

包的概述和注意事项：
	包：其实就是文件夹；
	作用：就是对类进行分类管理；
	举例：
		学生：增加，删除，修改，查询
		老师：增加，删除，修改，查询
	方案1：按功能分
		com.scy.add
		com.scy.delete
		...
	
	方案2：按照模块分
		com.scy.student
			addStudent
			deleteStudent
		com.scy.teacher
			addTeacher
			deleteTeacher

包的定义格式:
	package 包名;
	如果是多级包用.隔开即可;
注意：
	package必须放在程序第一条可执行语句；
	package在Java文件中只能有一个

导包

当类不在同一个包时，使用的时候，要加类的全路径名称；（不建议使用）
import cn.scy.Teacher;

7.权限修饰符4种

权限修饰符	本类中	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

标签：Java

拜师教育学员文章：作者:976-沈同学，转载或复制请以超链接形式并注明出处拜师资源博客。
原文地址：《6.3Java面对对象(下)》发布于2020-03-11

分享到：

赞(0) 打赏

热门标签

Java面对对象(下) – 2

1.final关键字

2.static关键字

静态成员变量的特点：

静态方法的的访问特点以及注意事项：

3.抽象类

抽象类概述：

抽象类的特点：

抽象类的成员特点：

抽象类的练习：

4.接口

接口的概述：

接口的特点：

类于类/类于接口/接口与接口的关系

抽象类与接口的区别

接口练习

练习1

练习2

5.多态的几种形式

6.包和导包

包

导包

7.权限修饰符4种

相关推荐

JavaWeb JSP

MQTT协议与EMQ

Mybatis二

Mybatis一

评论 抢沙发

评论前必须登录！

热门标签

置顶推荐

最新评论

分享文本海报

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

支付宝扫一扫打赏

微信扫一扫打赏

去评论

QQ咨询

去顶部

登录

评论抢沙发