JAVA从小白到大神第11章面向对象基础

郭源潮859

已于 2023-08-02 21:43:49 修改

阅读量16

点赞数

文章标签： java 开发语言 servlet

于 2023-07-21 11:23:36 首次发布

本文链接：https://blog.csdn.net/weixin_74385523/article/details/131847561

版权

11.1面向对象的三个基本特性

1.封装性

封装能够使外部访问者不能随意存取对象的内部数据，隐藏了对象的内部细节，只保留有限的对外接口。外部访问者不用关心对象的内部细节，使得操作对象变简单。

2.继承性

3.多态性

多态性是指在父类中成员变量和成员方法被子类继承之后，可以具有不同的状态或表现行为。

11.3类

11.3.1类的声明

Java语言中一个类的实现包括类声明和类体。类声明语法如下：

[public] [abstract|final] class className [extend superclassName] [implements interfaceNameList ] {

//类体

}

其中，class是声明类的关键字，className是自定义的类名：class前面的修饰符public，abstract，final用来声明类，它们可以省略，具体用法后面说。superclassName为父类名，

可以省略，如果省略，则该类继承Object类，Object类为所有类的根类，所有类都直接或间接继承Object；interfaceNameList是该类实现的接口列表，可以省略，接口列表中的多个接口之间用逗号分隔。

例如：

//Animal.java

public class Animal extend Object {

//类体

}

上述代码声明了动物（Animal）类，它继承了Object类。继承Object类extends Object代码可以忽略。类体是类的主体，包括数据和操作，即成员方法和成员变量。

11.3.2成员变量

声明成员变量语法格式如下：

class className{

[public | protected | private] [static] [final] type variableName//成员变量;

}

其中type是成员变量数据类型，variableName是成员变量名。type前的关键字都是成员变量修饰符。说明：

（1）public，protected和private修饰符用于封装成员变量。

（2）static修饰符用于声明静态变量，所以静态变量也称为“类变量”。

（3）final修饰符用于声明变量，该变量不能被修改。

例子：

//Animal.java

public class Animal extends Object{

//动物年龄

int age = 1;

//动物性别

public boolean sex = false;

//动物体重

private double weight = 0.0;

}

11.3.3成员方法

声明类体中成员方法语法格式如下：

class className{

[public | protected | private] [static] [final | abstract] [native] [synchronized]

type methodName([paramList]) [throws exceptionList] {

//方法体

}

其中，type是方法返回值数据类型，methodName是方法名。type签的关键词都是修饰符。说明：

（1）public，protected和private修饰符用于封装方法。

（2）static修饰符用于声明静态方法，所以静态方法也称为类方法。

（3）final | abstract不能同时修饰方法，final修饰的方法不能在子类中被覆盖；abstract用来修饰抽象方法，抽象方法必须在子类中实现。

（4）native修饰的方法，称为“本地方法”，本地犯法调用平台本地代码，不能实现跨平台。

（5）synchronized修饰的方法是同步的，当多线程方式同步方法时，只能串行地执行，保证线程是安全的。

方法声明中还有[paramList]部分，它是方法的参数列表。throws exceptionList是声明抛出异常列表。例子：

package ChapterEleven;

public class MemberMethods {
   public class Animals {//extends Objects {
       //动物年龄
       int age = 1;
       //动物性别
       public boolean sex = false;
       //动物体重
       private double weight = 0.0;

       public void eat() {
           //方法体
           return;
       }

       int run() {
           //方法体
           return 10;
       }

       protected int getMaxNumber(int number1,int number2) {
           //方法体
           if(number1 > number2) {
               return number1;
           }
           return number2;
       }

}

}

11.4包

11.4.4常用包

1.java.lang包

包含了java核心类，如Object，Class，String，包装类和Math等，还有包装类Boolean，Character，Integer，Long，Float和Double。使用java.lang包中的类型不需要显式使用import语句引入，它是由解释器自动引入的

2.java.io包

提供多种输入/输出流类，如InputStream，OutputStream，Reader和Writer/还有文件管理相关类和接口，如File和FileDesciptor类以及FileFilter接口。

3.java.net包

包含进行网络相关操作的类，如URL，Socket和ServerSocker等。

4.java.util包

包含一些实用工具类和接口，如集合，日期和日历相关类和接口。

5.java.text包

提供文本处理，日期格式化好数字格式化等相关类及接口。

6.java.awt和java.swing包

java.awt和java.swing包提供了Java图形用户界面开发所需要的各种类和接口，java.awt提供了一些基础类和接口，java.swing提供了一些高级组件。

11.5方法重载

处于使用方便等原因，在设计一个类时将具有相似功能的方法起相同的名字。例如，String字符串查找方法indexOf有很多不同版本。、

如:

int indexOf（int ch）：返回指定字符在此字符串中第一次出现处的索引。

int indexOf（int ch，int fronIndex）：返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

int indexOf（Sring str）：返回指定子字符串在此字符串中第一次出现处的索引。

int indexOf（String str，int fromIndex）：返回指定子字符串在此字符串中第一次出现处的索引，从指定索引开始搜索。

package ChapterEleven;

public class MethodOverloading {
   void receive(int i) {
       System.out.println("接收一个int参数");
       System.out.println("i = " + i);
   }

   void receive(int x, int y) {
       System.out.println("接收两个int参数");
       System.out.printf("x = %d, y = %d \r", x, y);

   }
   int receive(double x, double y) {
       System.out.println("接受两个double参数");
       System.out.printf("x = %f, y = %f \r" , x, y);
       return 0;
   }
}

//在HelloWorld.java文件中调用MethodOverloading

package ChapterEleven;

public class HelloWorld {
   public static void main(String[] args) {
       MethodOverloading mo = new MethodOverloading();
       //调用void receive(int i)
       mo.receive(1);

       //调用void receive(int x, int y)
       mo.receive(2, 3);

       //调用void receive(double x, double y)
       mo.receive(2.0,3.3);
   }
}

11.6封装性与访问控制

Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的。访问控制分为4个等级，私有，默认，保护和公有。

11.6.1私有级别

私有级别的关键字是private，私有级别的成员变量和方法只能在其所在类的内部自由使用，在其他的类中则不允许直接访问。私有级别限制性最高

例子：

package ChapterEleven;

public class PrivateClass {
   private int x;

   public PrivateClass() {
       x = 100;

   }

   private void printX() {
       System.out.println("Value of x is " + x);

   }

}

在HelloWorld.java文件中调用PrivateClass

package ChapterEleven;

public class HelloWorld {
   public static void main(String[] args) {

       PrivateClass p;
       p = new PrivateClass();

       //编译错误，PrivateClass中的方法PrintX（）不可见
       p.printX();

   }
}

11.6.2默认级别

默认级别没有关键字，也就是没有访问修饰符，默认级别的成员变量和方法，可以在其所在类内部和同一个包的其他类中被直接访问，但在不同包的类中则不允许直接访问。

例子:

package ChapterEleven;

public class DefaultClass {
   int x;

   public DefaultClass() {
       x = 100;
   }
   void printX() {
       System.out.println("Value Of x is " + x);
   }
}

//在相同包package ChapterEleven中调用DefaultClass类代码如下

package ChapterEleven;

public class HelloWorld {
   public static void main(String[] args) {

       DefaultClass p;
       p = new DefaultClass();
       p.printX();
   }
}
默认访问级别可以在同一包中访问，上述代码可以编译通过

若不在同一个包（package）中，则编译无法通过

11.6.3保护级别

保护级别的关键字是protected，保护级别在同一包中完全与默认访问级别一样，但是不同包中子类能够继承父类中的protected变量和方法，这就是所谓的保护级别。“保护”就是保护每个某个类的子类都能继承该类的变量和方法。

例子：

package ChapterEleven;

public class ProtectedClass {
   int x;

   public ProtectedClass() {
       x = 100;
   }
   void printX() {
       System.out.println("Value Of x is " + x);
   }
}

//在相同包中调用ProtectedClass代码如下

package ChapterEleven;

import ChapterEleven.ProtectedClass;

public class HelloWorld {
   public static void main(String[] args) {

       ProtectedClass p;
       p = new ProtectedClass();
       //同一包中可以直接访问ProtectedClass的方法printX（）
       p.printX();
   }
}
//在不同包中调用ProtectedClass

import ChapterEleven.ProtectedClass;

public class HelloWorld {
   public static void main(String[] args) {

       ProtectedClass p;
       p = new ProtectedClass();
       //编译错误，不同包中不能直接访问保护方法printX（）
       p.printX();
   }
}

该文件与ProtectedClass类不在同一包中，不同包中不能直接访问保护方法printX（），所以p.printX()方法无法编译通过。

//在不同包中继承ProtectedClass类代码如下

//默认包中SubClass.java文件

package SubClass;
import ChapterEleven.ProtectedClass;

public class Subclass extends ProtectedClass{
   void display() {
       //printX方法是从父类继承过来
       printX();
       //x实例变量是从父类继承过来
       System.out.println(x);
   }
}

11.6.4公有级别

不在同一个包中也可以直接访问只要导包
import ChapterEleven.ProtectedClass;

就可以直接访问。

提示：

访问成员有两种方式：一种是调用，即通过类或对象调用它的成员，如p.printX()语句；另一种是继承，即子类继承父类的成员变量和方法。

1.公有访问级别在任何情况下两种方式都可以。

2.默认访问级别在同一包中两种访问方式都可以，不可以在包之外访问。

3.保护访问级别在同一包中与默认访问级别一样，两种访问方式都可以。但在不同包外只能继承访问。

4.私有访问级别只能在本类中通过调用方法访问，不能继承访问。

11.7静态变量和静态方法

有一个Account（银行账户）类，假设他有三个成员变量：amount（账户金额），interestRate（利率），owner（账户名）。在这三个成员变量中，amount和owner会因人而异，对于不同账户这些内容是不同的，而所有账户的interestRate都是相同的。

amount和owner成员变量和账户个体有关，称为“实例变量”，interestRate成员变量和个体无关，或者说所有账户个体共享的，这种变量称为“静态变量”或“类变量”。

例子：

package SubClass;

public class Account {
   //实例变量账户金额
   double amount = 0.0;
   //实例变量账户名
   String owner;

   //静态变量利率
   static double interestRate = 0.0668;

   //静态方法
   public static double interestBy(double amt) {
       //静态方法可以访问静态变量和其他静态方法
       return interestRate * amt;
   }

   //实例方法
   public String messageWith(double amt) {
       //实例方法可以访问实例变量，实例方法，静态变量和静态方法
       double interest = Account.interestBy(amt);
       StringBuilder sb = new StringBuilder();
       //拼接字符串
       sb.append(owner).append("的利息是").append(interest);
       //返回字符串
       return sb.toString();
   }
}

调用Account代码：

package SubClass;

public class HelloWorld {
   public static void main(String[] args) {
       //访问静态变量
       System.out.println(Account.interestRate);
       //访问静态方法
       System.out.println(Account.interestBy(1000));

       Account myAccount = new Account();
       //访问实例变量
       myAccount.amount = 100000;
       myAccount.owner = "Tony";
       //访问实例方法
       System.out.println(myAccount.messageWith(1000));

       //通过实例访问静态变量
       System.out.println(myAccount.interestRate);
   }
}

11.8静态代码块

如果初始化静态变量不是简单常量，则需要进行计算才能初始化，可以使用静态（static）代码块，静态代码块在类第一次加载时执行，并且只执行一次。

例子：

package SubClass;

public class Account {
   //实例变量账户金额
   double amount = 0.0;
   //实例变量账户名
   String owner;

   //静态变量利率
   static double interestRate = 0.0668;

   //静态方法
   public static double interestBy(double amt) {
       //静态方法可以访问静态变量和其他静态方法
       return interestRate * amt;
   }

   //静态代码块
   static {
       System.out.println("静态代码块被调用。。。");
       //初始化静态变量
       interestRate = 0.0668;
   }
}

调用Account代码如下:

package SubClass;

郭源潮859

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA从小白到大神第11章面向对象基础

可以省略，如果省略，则该类继承Object类，Object类为所有类的根类，所有类都直接或间接继承Object；其中，class是声明类的关键字，className是自定义的类名：class前面的修饰符public，abstract，final用来声明类，它们可以省略，具体用法后面说。类体是类的主体，包括数据和操作，即成员方法和成员变量。多态性是指在父类中成员变量和成员方法被子类继承之后，可以具有不同的状态或表现行为。（2）static修饰符用于声明静态变量，所以静态变量也称为“类变量”。
复制链接

扫一扫