Java 面向对象

引用传递实际参数

关联数据结构

合成设计模式

数据表与简单 Java 类的映射关系

数据表与简单Java类之间的基本映射关系如下

  • 数据实体设计 = 类的定义
  • 表中的字段 = 类的成员属性
  • 表的一行记录 = 类的实例化对象
  • 表的多行记录 = 对象数组
  • 表的外键 = 引用关联

字符串

字符串比较

“==”：进行比较是数值比较，如果用对象比较，则比较的是两个内存的地址数；
涉及堆和栈的知识。
equals()：是类所提供的一个比较办法，可以直接进行字符出串内容的判断。

字符串常量是 String 类的匿名对象

字符串是匿名对象，会提前开辟好内存空间。
在进行字符串比较的时候，可以将字符串常量写在前面，调用 equals() 方法时候永远不可能出现“NopointerException”空指向异常。

String 类两种实例化方式区别

直接赋值的对象实例化处理

直接赋值，开辟一块堆内存和栈内存。
直接赋值时可以实现内存数据的共享。
Java 程序底层提供有专门的字符串池（字符串数组）。
直接赋值的过程中，会实现池数据的保存。池中有数据，就进行直接共享，没有，就写入。

直接赋值：只产生一个实例化对象，可以自动的将对象保存到对象池之中。重复利用。

构造方法实例化 String 类对象

String str = new String(“New”);
“New” 是匿名对象，会自动开辟堆内存存储。而 new 也会开辟新的对内存，存储空间会产生垃圾空间。

构造方法实例化的对象实际上是属于一种自己专用的内存空间，但是有些 String 类里面提供有帮助开发者手工入池的情况。使用 intern() 方法，实现对象池的统一管理。

构造方法：产生两个实例化对象，并且不会自动入池，无法实现对象重用。但是可以使用 intern() 方法实现入池操作。

String 对象池（常量池）

对象池是实现对象数据的共享处理。 Java 对象池分为两种：

  • 静态常量池：程序加载时（*class）自动将程序之中保存的字符串、类、以及类方法的信息，全部进行分配。
  • 运行时常量池：当程序夹杂之后，里面可能时常量池，时运行时常量池。

字符串内容不可修改

字符串数组，长度固定。
String 内容的修改会产生垃圾空间，而且指针会修改无数次。在开发中一般尽可能不使用字符串数组的频繁修改。
避免类似于“String str = x; str += x;”

主方法组成分析

public Static void main(String [] args)

  • public:开始点，开始结点是公共的。
  • static:程序执行是通过类名称完成的，所表示的方法是由类直接调用。所以此方法表示是由类直接调用的。
  • void:主方法是起点，开始以后就不可以返回。
  • main:定义好的方法名称。
  • String args[]:字符数组，可以实现程序启动参数。

2021/9/30

String 类常用方法

JavaDoc

Java API 文档。
在JDK 1.9 之前，Java所有的常用类在JVM 启动时加载，JDK 1.9 以后会进行模块化加载。
模块（Modle）之中包含大量的程序开发包（packge）。
String类的包在 Java.lang 之中。

包之中，类的完成定义，类相关说明信息，成员属性摘要，构造方法摘要（Deprecated是不建议使用的方法），方法摘要，详细说明。

字符串与字符数组

听完之后讲了什么？？？

字符串与字节数组

字符串与字节数组进行转换操作，进行了字符串与字符数组的转换是为了二进制的数据传输，或者进行编码转换。

  • public String(byte[] bytes)
    构造类型，将全部字节数组转变为字符；
  • public String (byte[] bytes, int offset, int length)
    构造，将部分字节数组转变为字符串。
  • public byte[] getBytes( )
    普通类型，将字符串转换为字节数组。
  • public byte[] getBytes(String charsetName) throws UnsupportedEncodingException
    普通类型，编码转换。

字符串比较

  • public boolean equals(String Objects)
    普通方法，区分大小写。
  • public boolean equalsIgnoreCase(String anotherString)
    普通方法，不区分大小写比较
  • int compareTo(String anotherString)
    普通方法，进行字符串大小比较。
    三种结果：> < = 。
  • int compareToIgnore(String str)
    不区分大小写

字符串查找

  • public public boolean contains(String s)
    普通类型，判断字符串是否存在。
  • public int index(String str)
    普通方法，从头查找指定字符串的位置，找不到返回 0 。
  • public int indexOf(String str, int formIndex)
    普通方法，从指定位置开始查找指定字符串的位置。
  • public int lastIndexOf(String str)
    普通方法，由后向前查找指定字符串的位置。
  • public int lastIndexOf(String str, int formIndex)
    普通方法，从指定位置后向前查找指定字符串的位置。
  • public boolean startsWith(String prefix)
    判断是否以指定的字符串开头
  • public boolean startsWith(String prefix, int toffset)
    普通方法，由指定位置判断是否以指定的字符串开头。
  • public boolean endsWith(String suffix)
    普通方法，判断是否以指定的字符串结尾。

字符串替换

  • public String replaceAll(String regex, String replacement)
    普通方法，全部替换
  • public String replaceFirst(String regex, String replacement)
    普通方法，替换首个

10-01

字符串拆分

  • public String[] split(String regex)
    普通类型，按照指定字符串全部拆分
  • public String[] spilt(String regex, int limit)
    普通类型，按照指定字符串拆分为指定个数。
    拆分不了，使用”//“

字符串的截取

  • public String substring(int beginIndex)
    普通类型，从指定索引截取到结尾
  • public String substring（int beginIndex, int endIndex）
    普通类型，从指定范围索引字符串范围中的子字符串。 
  1. public class StringDemo {
  2.     public static void main(String args[]){
  3.         Stringf str = "mnnkhij - .pxx";
  4.         int beginIndex = str.IndexOf(".", str.indexOf("xx")) + 1;
  5.         int endIndex = str.lastIndexOf("x");
  6.         System.out.println(str.substring(beginIndex.endIndex));
  7.     }
  8. }

字符串格式化

JDK 1.5 以后，类似于c语言的格式化操作出现，可以利用占位符实现数据的输出。常用”%c , %d…”;

  • public static String format(String format, 各种类型, ···args)

其它操作方法

  • public String concat(String str);
  • public String intern( )
    字符串入池
  • public boolean isEmpty( )
    普通类型，判空，不是null
  • public int length()
    普通类型，计算字符串的长度
  • public String trim()
    普通类型，去除左右的空格信息
  • public String toUpperCase()
  • public String toLowerCase() 
  1. class StringUtil {
  2.     public static String initcap(String str) {
  3.         if(str == null || "".equals(str)) {
  4.             return str;
  5.         }
  6.         if(str.length() == 1) {
  7.             return str.toUpperCase();
  8.         }
  9.         return str.subString(0, 1).toUpperCase() + str.substring(1)
  10.     }
  11. }
  13. public class StringDemo {
  14.     public static void main(string [] args) {
  15.         System.out.println(StringUtil.initcap("hello"));
  16.     }
  17. }

继承的定义与使用

继承问题

继承性：可以扩充已有类的功能。
合理的代码要有结构合理，易于维护，可重用性高。

继承的实现

使用 extern 关键字

  • class 子类 extern 父类 { }

很多情况下会把子类称为派生类，吧父类称为超类。（SuperClass）

2021-10-03

子类对象实例化流程

有父类实例化对象才能有子类。

super() 表示子类构造调用杜磊构造的语句，该语句只允许放在子类构造方法的首行，只会调用父类的无参构造，故而“super()” 写于不写无区别，但是当父类中没有无参构造的时候，必须利用 super() 明确有参构造。

继承相关限制

  • java 中不允许多重继承，只能多层继承。
  • 自己写继承，不应该超过三层
  • 子类会继承父类所有的操作内容，都会被继承， 私有属性也会隐式继承，可以通过方法间接访问。

方法覆写

父类功能不全但是需要保留父类中的方法与操作时需要覆写。

实例化子类对象，调用的方法是被子类覆写的方法，若没有覆写，则调用父类的方法。在子类方法覆写的时候，调用父类中的方法，就必须使用 super() 方法。

方法覆写的限制

覆写可以扩充父类功能，但是不可以有超过父类的访问权限。
实际开发 public 覆写。

  • 解释Override 和 Overloading 的区别；
  • Overloading 时返回参数是否相同？

Overloading: 重载
方法名称相同，参数类型以及个数不同
没有权限限制
发生在一个类中

Override: 覆写
方法名称、参数类型以及个数，返回值相同。
被覆写的方法不能拥有更严格的权限。
发生两个类中。

方法重载时没有对返回类型做出限制，但是应该保持返回类型的要执行。

属性覆盖

子类定义了与父类相同的属性名称时，发送属性覆盖。
属性发生了封装，覆盖就没有了意义。

  • super 与 this 的区别

程序类中使用 this 表示先从本类查找所需要的属性或者方法，如果本类不存在就查找父类定义。
如果使用super 表示不查找本类直接查找父类。
this 与 super 都可以进行构造方法的调用，但是 this() 调用的是本类构造，而 super() 是子类调用父类的构造，且两者都必须放在方法的首行，所以不能同时出现。
this 可以表示当前对象，super 不可以。

final 关键字

final 再程序中表示终接器的概念，在 Java 中，使用final 关键字可以实现：定义不能够被继承的类以及不能覆写的方法和常量。

  1. final class Channel {               //类不能被继承
  2.     public final void connect() {}  //方法不能被覆写
  3. }
  • 架构好的开发中 final 关键字少见，但底层开发中 final 比较常见。

final 关键字可以定义常量。 而常量是公共定义，为了体现共享概念，会使用 public static final 定义全局常量。全局常量的定义字母全部大写。

2021-10-05-01 /02：05AM

继承案例

数组操作

  1. class Array {
  2.     private int [] data;
  3.     private int foot;   //进行数组索引控制
  5.     public Array(int len) {   
  6.         if (len > 1) {
  7.             this.data = new int [len];   //开辟数组
  8.         } else {
  9.             this.data = new int [1];   //开辟空间
  10.         }
  11.     }
  13.     /*实现数组容量的扩充，给出扩充大小，实际大小，已有大小 + 扩充容量*/
  14.     public void increment(int num) {
  15.         int newData [] = new int [this.data.length + num];
  16.         System.arraycopy(this.data, 0, newData, 0, this.data.length);
  17.         this.data = newData;
  18.     }
  20.     /*数据增加*/
  21.     public boolean add(int num) {
  22.         if(this.foot < this.data.length ) {  //有位置
  23.             this.data[this.foot ++] = num;
  24.             return true;
  25.         }
  26.     }
  28.     public int [] getData() {
  29.         return this.data;
  30.     }
  31. }
  33. /*定义排序子类*/
  34. class SortArray extends Array {
  35.     public SortArray(int len) {
  36.         super(len);
  37.     }
  38.     public int [] getData() {    //获得排序结果-覆写方法
  39.         java.until.Arrays.sort(super.getData());
  40.         return super.getData();
  41.     }
  42. }
  44. /*定义反转子类*/
  45. class ReserveArray extends Array {
  46.     public ReservetArray(int len) {
  47.         super(len);
  48.     }
  50.     public int [] getData() {
  51.         int center = super.getData().length / 2;
  52.         int head = 0;
  53.         int tail = super.getData().length - 1;
  54.         for(int x = 0 ; x < center ; x++) {
  55.             int temp = super.getData() [head];
  56.             super.getData()[head] = super.getData().[tail];
  57.             super.getData()[tail] = temp;
  58.             head++;
  59.             tail--;
  60.         }
  61.         return super.getData();
  62.     }
  63. }
  65. public class JavaDemo {
  66.     public static void main(String args[]) {
  68.         ReserveArray arr = new ReserveArray(5);
  69.         Array arr = new Array(20);
  70.         Array arr = new Array(20);
  71.         Array arr = new Array(5);
  72.         Array arr = new Array(2);
  73.         arr.increment(10);
  74.         Array arr = new Array(1);
  76.         int result [] = arr.getData();
  77.         for(int temp : result) {
  78.             System.out.print(temp + "、");
  79.         }
  81.     }
  82. }

父类之中定义方法名称很重要，当功能相同时子类应该以覆写子类的方法为主要的考虑。