6.3Java面对对象(下)

976-沈同学

发表文章数:64

热门标签

首页 » Java » 正文

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

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

6.3Java面对对象(下)

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
标签:

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

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

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

支付宝扫一扫打赏

微信扫一扫打赏

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

登录

忘记密码 ?

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

Q Q 登 录
微 博 登 录