JAVA面向对象编程

最新推荐文章于 2024-07-30 10:06:36 发布

小月半会飞

最新推荐文章于 2024-07-30 10:06:36 发布

阅读量3.3k

点赞数 8

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/weixin_42775190/article/details/82466395

版权

JAVA基础专栏收录该内容

22 篇文章 3 订阅

订阅专栏

9.修饰符：static,final,abstract

10.interface 接口

11.开闭原则：

12.内部类

特征：封装，继承，多态（，抽象）

1.构造方法：

构造器:
构造方法(构造函数)
  1.构造器名称和类名一致
  2.没有返回值类型(8种基本类型,String,引用类型,void)
  3.一个类中可以有多个构造器,多个构造器靠参数列表(个数,顺序,类型)来区分
  4.构造器的调用:当类被实例化时调用(new)--通过（名+参数列表）调用
  5.如果你不给这个类提供构造器，JVM会给该类提供一个默认的无参的构造器
   如果你给这个类提供构造器，JVM不会给该类提供一个默认的无参的构造器
  作用:
  为了初始化对象方便,更合理的初始化对

2.this

this:当前类对象
1. this.
当前类的属性和当前类的方法
2. this()
当前的构造器，只能写在构造器的第一句

3.继承

1 .A is B(A是B)
2.关系是相对的
3.java中只支持单继承

4.父类

super:父类的对象
1. super.
   能调用父类的属性和父类的方法
2. super()
   调用父类的构造--通过参数列表
   只能写在构造器的第一句

5.重写

重写:
1.存在继承关系的两个类中方法
2.方法的名称一样，参数列表一样，返回类型也一样

6.重载

在同一个类中的多个方法,方法的名称相同，参数列表不相同,返回类型无所谓

7.访问修饰符

1）、public， private， protected，默认都可修饰成员变量，成员方法。

2）、public,默认可修饰顶层类。

3）、局部变量不能用访问修饰符。

4）成员变量或成员方法的访问控制：

位置	private	默认	protected	public
同一个类	是	是	是	是
同一个包内的类	否	是	是	是
不同包内的子类	否	否	是	是
不同包并且不是子类	否	否	否	是

8.单例的实现

单例：实例化出来的对象是同一个对象

方法：写一个私有的，静态的构造

1、通过静态方法实现

代码：

Public class Run{

       private static Run r=null;

       public static Run gerRun(){

                if(r==null){

                          r=new Run();

}

Return r;

}

}

Public class Transfer{

       Public static void main(String[] args){

                Run ru=Run.getRun();

                Sysetem.out.printlin(ru);

                Run ru1=Run.getRun();

                Sysetem.out.printlin(ru1);



}

}

运行结果：

Run @4554617c

2、通过静态块实现

public class demo02 {

    private static demo02 d=null;

    static {

        if(d==null){

            d=new demo02();

        }

    }

    public static demo02 getdemo02(){

        return d;

    }

 public class demo01 {

    public static void main(String[] args) {

        demo02 d1=demo02.getdemo02();

        System.out.println(d1);

        demo02 d2=demo02.getdemo02();

        System.out.println(d2);



    }

}

运行结果：

Run @4554617c

9.修饰符：static,final,abstract

（一）static-静态

1.static能修饰属性，方法，静态块

2.static修饰的属性:是多个对象共有的一块空间

3.static修饰属性，方法--可以不通过实例化对象得到，可以通过类名直接调用

4.静态方法和静态块中只允许使用静态属性

5.静态块是在类被加载时调用

（二）final:常量

1.final能修饰变量,方法,类

2.final修饰变量:不能被第二次赋值

3.final修饰方法:不能被重写

4.final修饰类:不能被继承

（三）abstract ：抽象类

1.用abstract 修饰的类就是抽象类

2.抽象类中可以有属性，方法，还可以有抽象方法

抽象方法：

A.用abstract 修饰的方法就是抽象方法

B.抽象方法只有方法的声明，没有方法的实现（没有{}）

3.抽象类不能实例化（new）

4.使用：用一个类去继承抽象类，并把这个抽象类中的所有抽象方法都“重写“，否则该类还是为抽象类

5.可以有构造方法，只是不能实例化

代码示例：

//通过父类声明，子类实例化来使用这个抽象类
public class Test{
    public static void main(String[] args){
        Person p=new Person_C();
        p.say();
        System.out.println(p.i);
    }
}

//由于抽象类不能实例化，通过继承实现抽象类，将所有抽象方法重写
public class Person_C extends Person{
    public  void say(){
        System.out.println("你好");
    }
}

//抽象类，可以有属性，方法，抽象方法
public abstract class Person{
    public int i=1;
    public abstract void say();
}

10.interface 接口

1.用interface修饰的东西就是接口

2.接口中可以有属性

接口中默认的属性类型为public static final类型（可省略）

3.接口中只能有方法的声明（或者抽象方法），不能有方法的实现

4.接口不能被实例化

5.用一个类去“实现”一个接口，实现的关键字是implements

实现接口时必须把所有的方法声明都实现，否则该类是一个抽象类

6.一个类可以实现多个接口，A extends B implements C,D,E

7.接口允许多继承

代码示例：

//用iterface修饰的就是接口
public interface Tools1{
    float G=9.8f;
//public static final float G=9.8;接口中的属性默认为public static final类型，可以省略
//接口中可以有方法的声明（或者抽象方法），不能有方法的实现
    public void usb();
//接口中不能有构造方法
}

public interface Tools2{
    float PI=3.141592653f;
    public void circle(int r);
}

实现方式一：

//用一个类去“实现”接口需要有implement关键字,接口可以多继承
public class PC implement Tools1,Tools2{
    //要对接口中的所有方法实现重写，否则该类是一个抽象类
    @override
    public void usb(){
        System.out.println("PC's usb.")
    }
    @override
    public void circle(int a){
        System.out.println(2*a*PI);
    }
}

实现方式二：

//一个类可以实现多个接口
public class Test1 extends Demo implements Tools1,Tools2{
    public static void main(String[] args) {
        Test1 t=new Test1();
        t.circle(15);
        t.usb();

    }
    @Override
    public void usb() {
        System.out.println("usb()");
    }

    @Override
    public void circle(int r) {
        System.out.println(2*r*PI);
    }
}

补充：满足继承关系的时候使用抽象类，不满足抽象关系的时候使用接口，但是我们日常工作中都使用的是接口。

11.开闭原则：

对扩展（继承，接口）开发，对修改关闭

12.内部类

代码示例：

public class A {
    int a=10;
//    内部类的实例化：内部类不能直接被实例化，在外部类实例化一个内部类对象
    public B bbb=new B();
    public void say(){
        System.out.println("...A...say()...");
    }
    class B{
        int b=100;
        public void say(){
            System.out.println("...B...say()...");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        A aaa=new A();
//        内部类的调用
        aaa.bbb.say();
        System.out.println(aaa.bbb.b);
    }
}

父类声明，子类实例化的特点：

对象是父类的对象，能调用父类的属性和方法，也能调用子类重写父类的方法