Javaopp面向对象04

苏十八

已于 2024-02-21 22:20:53 修改

阅读量768

点赞数 17

文章标签： java 开发语言笔记 idea 学习 jvm

于 2024-01-31 15:44:41 首次发布

本文链接：https://blog.csdn.net/2303_77543831/article/details/135943965

版权

生命周期不同：（什么时候生（创建），什么时候死（销毁））

成员变量和局部变量

位置：

成员变量：在类中定义局部变量：在方法中调用或者方法中的参数

权限修饰不同：

成员变量：可以使用权限修饰符（static）局部变量：不可以使用权限修饰符

初始化不同：

成员变量：

非静态---创建对象后，由构造方法初始化静态---类加载时初始化

局部变量：没有默认初始值，必须定义，赋值，使用前必须初始化

生命周期不同：（什么时候生（创建），什么时候死（销毁））

成员变量：随着对象的创建而存在，随着对象的销毁而消失

生（创建）死（销毁）

非静态创建对象对象被垃圾回收

静态类加载时类被加载

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

当方法被调用当方法执行结束

在内存中的位置不同：

成员变量：与对象一起在对内存中

非静态与对象在对空间存储

静态与类信息在方法区中存储

局部变量：与方法一样在栈空间中存储

抽象类，抽象方法

只有方法声明（定义 public void test(）),没有具体的实现

Animal

eat(){

动物吃东西

}

动物类型很大，在类体系结构位于上层，里面实现与大多数子类实现都可能不一样

在上层类中实现功能，就没有必要了，但是程序设计时，应该在上层定义这一类型应该有什么功能

然后让子类继承父类，在子类中对抽象方法进行重写

抽象类：被abstract关键字修饰的类，里面可能会包含抽象方法
当类中没有足够的信息（抽象方法）来描述一个具体的对象时

抽象类除了不能创建对象之外，类的其他功能都正常（成员变量，构造方法）

抽象类一般位于类结构的上层，用来定义有哪些功能，让具体的子类继承实现即可

静态的方法不能被修饰为抽象的方法的
一个类中可以定义多个抽象方法的

抽象方法,定义方法，没有具体的实现，子类进行重写

package com.ffyc.javaopp.day4.cxl;

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 abstract void eat();

    public void sleep(){
        System.out.println("闭着眼睛睡觉");
    }

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

当一个具体的类继承抽象类后
要么继承抽象类中抽象方法，
要么将此类继续声明为抽象的类

package com.ffyc.javaopp.day4.cxl;

//public abstract class Dog extends Animal{
public class Dog extends Animal{


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

package com.ffyc.javaopp.day4.cxl;

public class TestAnimai {
    public static void main(String[] args) {
        //new.Animai.eat();

        new Dog().eat();
    }
}

final关键字

final关键字可以修饰类，方法，参数，成员变量
final不能修饰抽象类和接口，因为final修饰的类不能继承
final修饰方法，修饰后方法不能被子类重写
final修饰方法参数,在方法内部不能修改参数值
final修饰成员变量

package com.ffyc.javaopp.day4.finaldemo;

public class Demo {

    //情况一：在编码时，值就确定了，就直接进行赋值，此种情况最好加上static关键字，让其在内存中只有一份
    static final int num = 10;

    public final void test(final int a){
             //a = 10;
    }

    public static void main(String[] args){
        Demo demo = new Demo();
             demo.test(20);
             demo.test(30);
             //demo.num = 30; 
    }

}

package com.ffyc.javaopp.day4.finaldemo;

public class T extends Demo{

    public T() {
        super();
    }
}

package com.ffyc.javaopp.day4.finaldemo;
 
public class Demo {

    //情况一：在编码时，值就确定了，就直接进行赋值，此种情况最好加上static关键字，让其在内存中只有一份
    static final int num = 10;

    //情况二：每一个对象中都有一个常量，必须在构造方法中为常量进行初始化，一旦初始化，值都不能更改
    final int count;

    public Demo(int count) {
        this.count = count;
    }

    public final void test(final int a){
             //a = 10;
    }

    public static void main(String[] args){
        /*Demo demo = new Demo(count);
             demo.test(20);
             demo.test(30);*/
             //demo.num = 30;
        new Demo(10);
        new Demo(20);
    }

}

接口

概念

类实现接口，一个类可以实现多个接口
MyInterfaceImpl类是MyInterface接口的实现类
一个类如果实现接口，
要么重写接口中抽象方法
要么将此类声明为抽象类

一个类只能直接继承一个类，间接多层继承多个类
一个类可以实现多个接口
一个接口可以继承多个接口

接口：
是一种更为彻底的抽象，主要用来定义功能
接口是不能被创建对象的，

jdk8之后接口可以定义4中内容：
1.静态常量
2.抽象方法
3.静态方法（jdk8之后才开始有的）
4.默认方法（jdk8之后才开始有的）

接口还可以继承其他多个接口

代码一

package com.ffyc.javaopp.day4.jk1;

 
public class MyInterfaceImpl extends Object implements MyInterface,C{

    @Override
    public void test() {

    }

    public static void main(String[] args) {
        new MyInterfaceImpl().test1();
    }

    @Override
    public void a() {

    }

    @Override
    public void b() {

    }

    @Override
    public void c() {

    }

    @Override
    public void d() {

    }
}

package com.ffyc.javaopp.day4.jk1;

 
public interface MyInterface extends A,B{

    int num = 10;//  public static final int num = 10;  静态常量

    void test();//  public abstract void test();  抽象方法

    //接口中定义静态方法，通过接口名直接访问
    public static void staticMethod(){

    }

    //默认方法，需要类继承，然后通过子类调用
    public default void test1(){

    }
}

package com.ffyc.javaopp.day4.jk1;

public interface A {

    void a();

}

package com.ffyc.javaopp.day4.jk1;

public interface B {

    void b();
    void c();
}

package com.ffyc.javaopp.day4.jk1;

public interface C {

    void d();
}

package com.ffyc.javaopp.day4.jk1;

public class Test {
    public static void main(String[] args) {
        System.out.println(MyInterface.num);
        MyInterface.staticMethod();

    }
}

实现

代码二

package com.ffyc.javaopp.day4.jk2;

public abstract class Animal {

    private String name;
    private int age;

    public abstract void eat();

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

package com.ffyc.javaopp.day4.jk2;


public class Bird extends Animal implements Fly{

    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }
}

package com.ffyc.javaopp.day4.jk2;


public class Dog extends Animal implements Run{

    private String type;

    @Override
    public void eat() {

    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public void run() {

    }
}

package com.ffyc.javaopp.day4.jk2;

public class Fish extends Animal implements Swim,Fly{

    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }

    @Override
    public void fly() {

    }
}

package com.ffyc.javaopp.day4.jk2;

public interface Fly {
    void fly();
}

package com.ffyc.javaopp.day4.jk2;

public interface Run {
    void run();
}

package com.ffyc.javaopp.day4.jk2;

public interface Swim {
    void swim();
}

接口和实现类之间也是可以有多态关系的
用一个接口，表示一类拥有此功能的类

package com.ffyc.javaopp.day4.jk2;


public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Bird();
        Animal animal3 = new Fish();

        Swim swim = new Fish();
        Fly fly1 = new Bird();
        Fly fly2 = new Fish();
        Run run = new Dog();
    }
}

苏十八

关注

17
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Javaopp面向对象04

成员变量：在类中定义局部变量：在方法中调用或者方法中的参数。抽象类一般位于类结构的上层，用来定义有哪些功能，让具体的子类继承实现即可。抽象类除了不能创建对象之外，类的其他功能都正常（成员变量，构造方法）在上层类中实现功能，就没有必要了，但是程序设计时，应该在上层定义这一类型应该有什么功能。静态的方法不能被修饰为抽象的方法的。一个类中可以定义多个抽象方法的。局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
复制链接

扫一扫