2019-7-8 [JavaSE] 多态及应用 instanceof运算符 类型转换 UML-泛化 实现 依赖 关联 字符串比较 API合集 compareTo() 源码

1.多态

特征:

1.重写；
2.父类引用 指向 子类的对象；
接口引用 指向 实现类的对象。

2.多态应用

类

class Base{int n;public void f() {System.out.println("base_f");}
}
class Sub1 extends Base{int m;public void f() {System.out.println("sub1_f");}public void method() {}
}
class Sub2 extends Base{int x ;public void f() {}public void function() {}
}
public class TestDemo {public static void main(String[] args) {Base sub1 = new Sub1();sub1.f();System.out.println(sub1.n);//多态:子类独特的特征和行为不能使用。
//		sub1.method();}
}

接口

interface Info{public void af();
}
class InfoImpl1 implements Info{public void af() {System.out.println("info1 _ af");}public void ff() {}
}
public class TestInfo {public static void main(String[] args) {Info info1 = new InfoImpl1();info1.af();//多态：实现类独特的特征和行为不能使用。
//		info1.ff();}
}

参数

3.instanceof运算符

4.类型转换

实例:

class Pet{private String name;public Pet(String name) {this.name = name;}public String getName() {return name;}public void eat() {System.out.println("吃");}
}
class Dog extends Pet{public Dog(String name) {super(name);}public void eat() {System.out.println("吃骨头");}public void run() {System.out.println("小狗跑了");}
}
class Cat extends Pet{public Cat(String name) {super(name);}public void eat() {System.out.println("吃鱼");}public void play() {System.out.println("小猫去玩了");}
}
5.类型转换实例：
由下向上转换
class PetHospital{//看病                                  父类类型           向上类型转换public void treatment(Pet pet) {// Pet pet = new Dog(); System.out.println("给" + pet.getName() + "看病");pet.eat();4.instanceof的使用实例：if(pet instanceof Dog) {//是Dog ,true, 不是 falseDog dog = (Dog)pet;dog.run();}else {Cat cat = (Cat)pet;cat.play();}}}
public class TestHospital {public static void main(String[] args) {Dog wangwang = new Dog("旺旺");PetHospital hos = new PetHospital();hos.treatment(wangwang);Cat xiaohua = new Cat("小花");hos.treatment(xiaohua);=}
}

5.UML之类图

类：
第一部分：类名；
第二部分：属性访问修饰符:  -  private默认#  protected+  public   

第三部分:方法

1.泛化

   继承：父类和子类。语法：extends 

2.实现

   接口和实现类：语法：implements 

3.依赖

  使用关系。语法：局部变量

4.关联

  拥有的关系。语法：成员变量
对象的数目：一对一：   1 ..1 一对多：   1 .. * 多对多：    * .. *
聚集 : 强关联。整体和局部，局部离开了整体可以独立存在。语法： 局部类 作为整体类的成员变量。组合： 强聚集。整体和局部，局部离开了整体不能独立存在。

6.字符串

6.1 String类

String：字符串类。 不可变类（一旦对象创建了 ，字符序列不能更改）。
内存存储：

//创建一个字符串String s1 = "hello";  // "hello"存在方法区的常量池// (2)     堆String s2 = new String(); // 空串String s3 = new String("hello");// 参数 作为字符序列 创建的一个字符串s3String s4 = null;String s5 = new String("tom");/** 底层：JDK8.0字符串表示* private final char value[] = new char[5]; // {'h','e','l','l','o'};* 不可变：private :私有  ，类外不能访问*        final: 对象不能更改*        没有提供公共的访问方式修改元素的值。  */

6.2 字符串比较：

		String s1 = "hello";String s2 = "hello";String s3 = new String("hello");String s4 = new String("hello");String s5 = "tom";//== 判断地址System.out.println(s1 == s2);// trueSystem.out.println(s3 == s4);// falseSystem.out.println(s1 == s3);// falseSystem.out.println(s1 == s5);// false

7.API

一.	// String不可变String s1 = "hello";//1. 连接字符串System.out.println(s1.concat("tom"));//"hellotom"s1.concat("tom");System.out.println(s1);// "hello"s1 = "hellotom";System.out.println(s1);// "hellotom"//2. 字符串长度System.out.println(s1.length());//5 //3. 字符序列是否相等,区分大小写System.out.println("hello".equals("hello"));System.out.println("hello".equals("Hello"));// false//4. 不区分大小写 Yes ,YES ,yesSystem.out.println("hello".equalsIgnoreCase("Hello"));//true //5. 大写转换System.out.println("HeLLo".toUpperCase());//HELLO//6.小写转换System.out.println("HeLLo".toLowerCase());//hello//  位置// 索引           01String s = "hellotomtomabcabc";// 7 获得参数字符串  在 当前字符串中 第一次出现的位置索引System.out.println(s.indexOf("tom"));// 5System.out.println(s.indexOf("xyz"));// -1 不存在返回-1 // 8 获得参数字符串  在 当前字符串中 最后一次出现的位置索引System.out.println(s.lastIndexOf("tom"));// 8// 9. 获得指定位置的一个字符System.out.println("hello".charAt(0));// 'h'// 10. 取子串//  "helloabctom"//   从起始位置截取  到 字符串末尾System.out.println("helloabctom".substring(8));// tom// 11. 从起始位置 取到 终止位置的前一位 [起始位置，终止位置)System.out.println("helloabctom".substring(5, 8));// abc
二.String s = "	h	e	l	lo	";//12.去除 前后 空格System.out.println(s.trim());//"h	e	l	lo"]//13.替换：第二个参数替换第一个参数System.out.println(s.replace("l", "abc"));//"	h	e	abc	abco	"//去除所有空格System.out.println(s.replace("	", ""));//"hello"//14.是否已参数字符开头，是则trueSystem.out.println("hello.java".startsWith("he"));//true//15.是否已参数字符结尾，是则trueSystem.out.println("hello.java".endsWith("java"));//true//比较字符串的大小/** 规则：* 	 当前字符串  等于  参数字符串  结果  ：0* 		           大于			     ：正数*  	           小于			     ：负数*  比较ASCII码值，字母表里靠前的小，靠后的大，输出的是前减后的答案*  */System.out.println("ab".compareTo("ab"));//0System.out.println("ab".compareTo("abc"));//-1System.out.println("ad".compareTo("ab"));//2System.out.println("ae".compareTo("ab"));//3System.out.println("ab".compareTo("ad"));//-2System.out.println("中国".compareTo("中国"));//0//17.str 转换成 char数组String str = "abc";//'a','b','c'char [] crs = str .toCharArray();for(char cr : crs){System.out.println(cr);}//18.按照指定参数字符串  将当前字符串分割  成一个String[]String sg = "aa bb cc dd ee";String [] sgs = sg.split(" ");for (String ss : sgs) {System.out.println("元素是" +ss);}//元素是aa//元素是bb//元素是cc//元素是dd//元素是ee//19.返回参数字符串  在当前字符串中是否存在 ，存在trueSystem.out.println("hello".concat("he"));//20.构造器String str1 = new String(new char[] {'a','b','c'});System.out.println(str1);//abc//21.从参数char[]创建一个字符串对象String str2 = String.copyValueOf(new char[]{'x','y','z'});System.out.println(str2);//xyz//    从参数char[]创建一个字符串对象                    ,从哪，几个str2 = String.copyValueOf(new char[] {'a','b','c','d'}, 1, 2);System.out.println(str2);// "bc"// 22 返回字符串对象对应的 常量池中存储的那个字符串常量对象String str3 = new String("hello");System.out.println(str3.intern());// "hello"

12.trim()
将String两端的空白字符删除后，返回一个新的String对象。如果没有改变发生，则返回原String对象。例子如下：

strNew = "          I am a lucky string.            ";  
System.out.println(strNew.trim()); //trim,输出：I am a lucky string.  

13.replace()
String replace(char oldChar, char newChar)，从这个函数原型中就可以看出就是将String中的oldChar替换成newChar啦。是全部替换哦，例子如下：

System.out.println(str.replace('a', 'A'));        //replace，输出：I Am A lucky string.  

14.startsWith()
boolean startsWith(String prefix)判断是否以prefix开头，是返回true，反之，则返回false

15.boolean endsWith(String suffix)
判断是否以prefix结尾，是返回true，反之，则返回false

16.compareTo()
public int compareTo(String anotherString)，按字典顺序比较两个String的大小哦。字典顺序是说a<b<c，返回值有三种可能：1，0，-1分别表示大于，等于，小于。例子如下：

1.if (str.compareTo("I am a unlucky string.") > 0) {   //compareTo(),Output:I am smaller  
2.    System.out.println("I am bigger");  
3.} else {  
4.    System.out.println("I am smaller");  
5.}  

compareTo() 源码：

public int compareTo(String anotherString) {int len1 = value.length;int len2 = anotherString.value.length;int lim = Math.min(len1, len2);char v1[] = value;char v2[] = anotherString.value;int k = 0;while (k < lim) {char c1 = v1[k];char c2 = v2[k];if (c1 != c2) {return c1 - c2;}k++;}return len1 - len2;
}

17.toCharArray()
将String转换成一个char数组，例子如下：

1.dst = str.toCharArray(); //toCharArray()  
2.System.out.println(dst);   //output:I am a lucky string.  

18.见上
19.contains()
boolean contains(CharSequence s)，判断源String中是否含有s。包含则返回1，不包含则返回0。关于什么是CharSequence，本文不赘述，请自行百度。例子如下：

1.if (str.contains("lucky")) {//contains()，
//Output:<span style="font-family: 
//Arial, Helvetica, sans-serif;">I contain lucky word</span>  
2.    System.out.println("I contain lucky word");  
3.} else {  
4.    System.out.println("I don't contain lucky word");  
5.}  

20.见上
21.见上
22.intern()
为每一个唯一的字符序列生成且仅生成一个String引用。什么意思呢？就是说某一个字符序列已经存在的话，那么就返回该字符序列对应的引用，例子如下:

1.System.out.println(str3 == str4);//输出：false  
2.str4 = (str1 + str2).intern();   //重点：intern()  
3.System.out.println(str3 == str4);//输出：true  

8.编写：多态与inof比较

class Pet{private String name;public Pet(String name) {this.name = name;}public String getName() {return name;}public void eat() {System.out.println("吃");}
}
class Dog extends Pet{public Dog(String name) {super(name);}public void eat() {System.out.println("吃骨头");}public void run() {System.out.println("小狗跑了");}
}
class Cat extends Pet{public Cat(String name) {super(name);}public void eat() {System.out.println("吃鱼");}public void play() {System.out.println("小猫去玩了");}
}
class PetHospital{//看病                                  父类类型           向上类型转换public void treatment(Pet pet) {// Pet pet = new Dog(); System.out.println("给" + pet.getName() + "看病");pet.eat();if(pet instanceof Dog) {//是Dog ,true, 不是 falseDog dog = (Dog)pet;dog.run();}else {Cat cat = (Cat)pet;cat.play();}}}
public class TestHospital {public static void main(String[] args) {Dog wangwang = new Dog("旺旺");PetHospital hos = new PetHospital();hos.treatment(wangwang);Cat xiaohua = new Cat("小花");hos.treatment(xiaohua);}}

9.编写：参数多态 员工回家

/*** 练习：参数多态* 员工乘坐不同的交通工具回家*/
abstract class TrafficTool{public abstract void run();
}
class Car extends TrafficTool{public void run() {System.out.println("汽车行驶中");}
}
class Tube extends TrafficTool{public void run() {System.out.println("地铁行驶中");}
}
class Employee{private String name;public Employee(String name) {this.name = name;}public void goHome(TrafficTool tool) {System.out.println(this.name + "回家了");tool.run();}
}
public class TestTrafficTool_exam {public static void main(String[] args) {Employee aibiancheng = new Employee("艾编程");Car car = new Car();aibiancheng.goHome(car);Employee aixuexi = new Employee("艾学习");Tube tube = new Tube();aixuexi.goHome(tube);}
}

10.注意

1.抽象类主要是提供模板的作用
2.接口的访问修饰符只能是默认和pubic类型
2.接口与抽象类的异同点:
相同点：都不能创建对象；都可以定义抽象方法；普通的子类或实现类 必须重写父类或者父接口中的所有抽象方法（抽象类除外）
不同点：语法不通；念不同；设计不同
3.多态里，子类赋值给父类类型
4.多态里，由上向下转换类型，需要使用强转
5.instanceof 判断输进来的是否是设定的类型，是则返回true，不是就返回false
6.重写是一个方法，而且是实例方法
7.除了重写都看数值运算符的左边
8.重写一般都是在同一个类里的
9.运行时多态是看数值运算符的左边，因为它是重写
10.编译器能确定的才会被存在常量池中
11.== 这个符号比较的是地址
12.String是不可变类
13.对象一旦创建，字符序列绝对不能更改