Java 接口实现变量赋值 java接口中的变量能继承么

转载

boyboy 2024-07-24 18:17:58

文章标签 Java 接口实现变量赋值 java 子类父类修饰符 文章分类 Java 后端开发

复习java的知识点，java支持的概念如下

多态
继承
封装
抽象
类
对象
实例
方法
消息解析

面向对象的三大特征：继承，多态，封装

1.一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

类的方法中的变量

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问

成员变量包括静态变量(类变量)和实例变量

实例变量：独立于方法之外的变量，没有static修饰，当一个对象被实例化之后，每个实例变量的值就确定了

//实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
import java.io.*;
public class Employee{
   // 这个成员变量对子类可见
   public String name;
   // 私有变量，仅在该类可见，一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]){
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

静态变量(类变量)：类变量也声明在类中，方法体之外，但必须声明为 static 类型。独立于方法之外的变量，存在static修饰

//静态变量在程序开始时创建，在程序结束时销毁
//静态变量除了被声明为常量外很少使用。常量是指声明为 public/private，final 和 static 类型的变量。常量初始化后不可改变。
import java.io.*;
public class Employee{
   //salary是静态的私有变量
   private static double salary;
   // DEPARTMENT是一个常量
   public static final String DEPARTMENT = "Development ";
   public static void main(String args[]){
      salary = 1000;
      System.out.println(DEPARTMENT+"average salary:"+salary);
   }
}

public class Variable{
    static int allClicks=0;    // 类变量

    String str="hello world";  // 实例变量
 
    public void method(){
        int i =0;  // 局部变量
    }
}

总结如下：

1、不管父类中的成员变量是静态的还是非静态的，子类统统拥有（这里不用继承概念）。

2、不管父类中的成员变量是被子类隐藏了还是没有被子类隐藏，子类统统拥有

3、不管父类中的成员变量是私有的还是其他，子类统统拥有，但是私有的不能被子类直接访问，只能通过从父类中继承的set和get方法来访问。就像上面那句话说的那样，对父类的私有变量具有拥有权，但是不具有使用权，只能通过从父类中继承的set和get方法来使用。

2.构造方法(构造器)

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

使用 new 创建对象时，会调用构造方法初始化对象。

//构造方法实例
public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // 这个构造器仅有一个参数：name
   }
}
//创建对象实例
public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("Puppy Name is :" + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );    //使用new创建对象时，会调用构造方法初始化对象
   }
}

3.访问实例变量和调用成员方法

通过创建的对象来实现实例变量的访问，调用类(成员)中的的方法

4.源文件声明规则

一个源文件中定义了多个类，存在import和package语句时，要注意以下规则

一个源文件只能有一个public类，可以有多个非public类

源文件的命名和public类的命名保持一致

如果一个类定义在某个包中，那么package语句应该在源文件的首行

如果存在import语句，那么应该在package语句之后

在同一源文件中，不能给不同的类不同的包声明，import和package语句定义保持有效。

5.java包

java包主要对类和接口进行分类。当开发java程序时，编写的类很多，对类和接口进行分类是必须进行的。

import语句

import java.io.*;    //将会命令编译器载入 java_installation/java/io 路径下的所有类

6.java的两大数据类型

内置数据类型

引用数据类型

6.1内置数据类型-八种数据基本类型

六种数据类型(四个整数型，两个浮点型)，一种字符类型，一种布尔型

byte型

short型(短整型)

int型(整形)

long(长整型)

float(单精度浮点型)

double(双精度浮点型)

char(字符型)

boolean(布尔型)

可以通过对应包装类的方法来查看基本类型数值的取值范围

// byte
    System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
    System.out.println("包装类：java.lang.Byte");
    System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
    System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
    System.out.println();

//输出结果
    基本类型：byte 二进制位数：8
    包装类：java.lang.Byte
    最小值：Byte.MIN_VALUE=-128
    最大值：Byte.MAX_VALUE=127

6.2引用数据类型

使用类创建一个对象时，会使用构造函数创建一个引用类型变量，可以使用它们访问所引用的对象，这些变量在声明时被指定为一个特定的类型。变量一旦被声明后，其类型不能更改

对象和数组都是引用数据类型

所有引用类型的默认值都是null

7.java常量

常量指不能改变的量。 在Java中用final标志，声明方式和变量类似
final double PI = 3.1415927;

8.java中特殊的转义字符序列

Java 接口实现变量赋值 java接口中的变量能继承么_父类

9.java修饰符

修饰符分为两类：访问修饰符，非访问修饰符

//修饰符用来定义类、方法或者变量，通常放在语句的最前端
public class className {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

9.1访问控制修饰符

Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持4种不同的访问权限。

默认的，也称为 default，在同一包内的类可见，不使用任何修饰符。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为 public。

String version = "1.5.1";
boolean processOrder() {
   return true;
}

私有的，以 private 修饰符指定，在同一类内可见。被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

原则上来说，private属性不能被子类继承访问，但是可以通过public方法来访问。

子类可以拥有父类中的private成员变量，但是只有拥有权，没有使用权

子类不能直接访问父类中被声明为private的属性，子类只能在父类中写一个public的getXXX的方法来获取父类中的private属性，子类就调用父类的getXXX来获取private属性

总结如下：

1、不管父类中的成员变量是静态的还是非静态的，子类统统拥有（这里不用继承概念）。

2、不管父类中的成员变量是被子类隐藏了还是没有被子类隐藏，子类统统拥有

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}
//Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个public方法：getFormat() （返回format的值）和setFormat(String)（设置format的值）

公有的，以 public 修饰符指定，对所有类可见。声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。

Protected 访问修饰符不能修饰类和接口

子类能访问 Protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

//下面的父类使用了 protected 访问修饰符，子类重载了父类的 openSpeaker() 方法。
class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

class StreamingAudioPlayer {
   boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

9.2非访问修饰符

static 修饰符，用来创建类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

9.2.1 static

static关键字声明变量，是独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝，局部变量不能被声明为static变量

static关键字声明方法，是独立于对象的静态方法，静态方法不能使用类的非静态变量。

9.2.2 final

final 变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final 方法

类中的 Final 方法可以被子类继承，但是不能被子类修改。

声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

final类不能被继承

9.2.3 abstract修饰符

抽象类：抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

抽象方法：

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();

//在抽象类中定义了一个抽象方法
public abstract class SuperClass{
    abstract void m(); //抽象方法
}
//子类继承了抽象类，并在子类中实现抽象类的抽象方法
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

9.2.4 synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。Synchronized 修饰符可以应用于四个访问修饰符。

public synchronized void showDetails(){
.......
}

9.2.5 trancient修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机 (JVM) 跳过该特定的变量。

9.2.6 volatile修饰符

volatile 修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    //一个线程调用run()方法
    public void run()
    {
        active = true;
        while (active) // line 1
        {
            // 代码
        }
    }
    //一个线程调用stop()方法，此时line1中active位于缓冲池中的值被使用
    public void stop()
    {
        active = false; // line 2    //因为active值是被volatile修饰，所以active的值被强制为ture
    }
}