admin 管理员组

文章数量: 1184232

2019

文章目录

• Object类
• • 1.equals()
  • hashCode()：hash算法
  • toString():
• 一、final
• • 修饰： 类 ，方法，变量；
  • • 类： 此类不能被继承；
    • 方法：不能被重写；
    • 变量: 常量。
    • 使用常量好处:
    • 精心设计一个可以被继承的类：
• 二、实现关系
• 三、抽象类
• • 分析：
  • 抽象类： 只定义了抽象的行为，没有具体实现相应的行为。
  • 注意：
• 四、接口
• • 1.语法JDK8.0
  • 2.接口特点：
  • 3.接口和抽象类异同
• 五、多态
• • 语法:(特征)
  • 多态应用：
  • 多态的好处：
  • • 1.多态应用
    • • 类多态：
      • 接口多态：
      • 参数多态：
    • 2.运算符
    • 3.类型转换
• 六、UML之类图
• • 1.泛化
  • 2.实现
  • 3.依赖
  • 4.关联

Object类

1.equals()

判断两个对象是否相等。

Object类的原码:

public boolean equals(Object obj) {return (this == obj);
}

String类的原码：

public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])// 对应位 的字符比较 return false;i++;}return true;}}return false;}

重写equals();

class Employee{// 父类 Objectprivate int age;public Employee(int age) {this.age = age;}public int show() {return age;}
/*  @Overridepublic boolean equals(Object obj) {// this  , obj// this.age  (Employee)obj.age// guojing.equal("hello")  Employee emp = (Employee)obj;// (Employee)"hello"return this.age == emp.age ? true : false;}*/// 系统自动生成的代码@Overridepublic boolean equals(Object obj) {// this->guojing  obj ->yangkang if (this == obj)// guojing.equals(guojing) agereturn true;if (obj == null)// guojing.equals(null) falsereturn false;// guojing.getClass();if (this.getClass() != obj.getClass())// guojing.equals("hello")  -> Employee : Stringreturn false;Employee other = (Employee) obj;if (this.age != other.age)return false;return true;}}
public class TestEmployee {
​public static void main(String[] args) {Employee guojing = new Employee(22);Employee yangkang = new Employee(22);boolean r = guojing.equals(guojing);System.out.println(r);// true
​}
​
}
+

getClass();

class Person{private String name;private int age;public Person(String name, int age) {super();// Object(){}this.name = name;this.age = age;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}
}
public class TestPerson {public static void main(String[] args) {Person guojing = new Person("guojing",18);// 对象的数据类型：System.out.println(guojing.getClass().getName());}}

哈希值：（散列值）对象（数据）的一个唯一的标识。
通过 一定的算法 算出来的数据。

hashCode()：hash算法

class Student{private int no;private String name;public Student(int no, String name) {this.no = no;this.name = name;}public int getNo() {return no;}public String getName() {return name;}public String show() {return no + "," + name;}
/*  @Overridepublic int hashCode() {return no;}*/@Overridepublic int hashCode() {
//      final int prime = 31;int result = 1;result = 31 * result + no;return result;}}
public class TestHashCode {public static void main(String[] args) {Student guojing = new Student(111,"郭靖");System.out.println(guojing.hashCode());}
}getClass():public static void main(String[] args) {// demo -> Object  new Demo() ->day0810.DemoObject demo = new Demo();System.out.println(demo.getClass());// 获得字节码文件对应的对象// day0810.DemoSystem.out.println(demo.getClass().getName());// 获得的是new Demo()的类型
}

toString():

使用print() 或 println()方法 输出对象名时 ，系统会自动调用toString()方法的。

class Employee{private int no;private String name;public Employee() {super();// TODO Auto-generated constructor stub
}public Employee(int no, String name) {super();this.no = no;this.name = name;}
​public int getNo() {return no;}
​public String getName() {return name;}
/*  public String show() {return no + "," + name;}*/
​@Overridepublic String toString() {// TODO Auto-generated method stubreturn no + "," + name;}}
public class TestEmployee {
​public static void main(String[] args) {Employee guojing = new Employee(11,"郭靖");/**    public String toString() {*      // return this.getClass().getName() + "@" + Integer.toHexString(hashCode());}*/// day0810.Employee@15db9742System.out.println(guojing);// 隐式调用toString
//      System.out.println(guojing.toString());// 显示调用toString()
​}
​
}

finalize(); 垃圾回收器 释放对象之前调用。

class Teacher{int no;@Overrideprotected void finalize() throws Throwable {// 释放资源System.out.println("this-->" + this);}}
public class TestTeacher {public static void main(String[] args) {Teacher guojing = new Teacher();System.out.println(guojing.toString());// day0917.Teacher@15db9742
//		System.out.println(guojing.no);
//		System.out.println(guojing.no);guojing = null;
//		System.out.println(guojing.no);// 空指针// 强制垃圾回收 :通知垃圾回收器System.gc();// }}

一、final

修饰： 类 ，方法，变量；

类： 此类不能被继承；

1 最终版本的类；
2.为了类的安全性；
3.类复杂，方法之间有复杂的调用关系。

方法：不能被重写；

所有的子类调用同一个版本的父类中的方法。

变量: 常量。

常量：值不能改变的量.
命名规范:每个单词字母都大写，多个单词用下划线 连接。

使用常量好处:

1.提高了安全性；
2.提高了可维护性;
3.提高了可读性。

精心设计一个可以被继承的类：

1 继承的层次 控制在 2 - 3层；
2. 提供良好的文档说明；说明方法功能的自用性，重写后带来什么影响
3.隐藏类的实现细节，private; 存储空间
只对子类开放 protected ; settter
对所有用户都开放 public . getter
不允许子类重写的方法用 final.

public class TestFinal {
​public static void main(String[] args) {
//      System.out.println(Byte.MAX_VALUE);final double PI = 3.1415926;System.out.println(PI);// 引用类型
/*      final int [] arr = new int[3];
//      arr = new int[4];// 对象一旦 确定了，就不能更改.arr[0] = 22;// 数组对象元素值 可以更改arr[1] = 55;*/final double LENGTH = 22.2;final double WIDTH = 11.1;
//      double s =  22.2 * 11.1;double s = LENGTH + WIDTH;System.out.println(s);}
​
}

二、实现关系

组合: 类和类之间的关系，整体 和 局部的关系。
语法：
局部类作为 整体类的实例成员变量。

class 整体类{局部类 对象 = new 局部类（）；}
整体类 对象= new 整体类（）；
// 局部类
class Heart{public void beat() {System.out.println("心跳");}
}
class Wolf1{Heart heart = new Heart();public void run() {System.out.println("跑");}
}
/*class Wolf1{private Heart heart = new Heart();public void beat() {heart.beat();}public void run() {System.out.println("跑");}
}*/public class TestAnimal2 {
​public static void main(String[] args) {Wolf1 wolf = new Wolf1();wolf.heart.beat();wolf.run();
​}
​
}

三、抽象类

分析：

1.不适合创建对象；
2.使用的都是子类的对象；
3.模板的作用

抽象类： 只定义了抽象的行为，没有具体实现相应的行为。

语法；

注意：

1.不能被实例化（不能创建对象）;new
2. 普通的子类 继承 抽象父类 时， 必须 重写实现抽象父类中
的所有抽象方法；(但是抽象的子类除外)
3. 抽象类中的抽象 方法 可以定义也可以不定义；
4. 构造不能定义为抽象的；
5.abstract 是一个修饰符， 不能 private ,final ,static 一起连用。

四、接口

1.语法JDK8.0

public
默认 帕斯卡

接口的成员：
1.接口中的所有成员都是 public;
2.常量：pu在这里插入代码片blic static final;
3.抽象方法： public abstract

接口： 一组功能的封装。

// 接口
interface WebBank{// public abstract void webService();void webService() ;// 网上支付
}
// 实现类            实现                  接口
class Jingdong implements WebBank{@Overridepublic void webService() {System.out.println("京东实现了网上支付功能");}   
}
class Taobao implements WebBank{@Overridepublic void webService() {System.out.println("淘宝实现了网上支付");}}
public class TestWebBank {
​public static void main(String[] args) {Jingdong jd = new Jingdong();jd.webService();Taobao tb = new Taobao();tb.webService();
​}
​
}

2.接口特点：

1.接口不能创建对象；
2.普通的实现类必须实现接口中的所有抽象方法（抽象的实现类除外）；
3.实现类可以实现多个接口的功能；
4.接口可以多继承。

interface ThreeElectric{void threeService();// 3
}
interface TwoElectric{void twoService();// 2
}
// 接口可以多继承:接口功能的扩展
interface Socket extends ThreeElectric,TwoElectric{void SocketService();   
}
class Goods{// 功能
}
class Computer extends Goods implements Socket{ @Overridepublic void twoService() {System.out.println("外置设备使用两项电通电");}@Overridepublic void threeService() {System.out.println("计算机使用三项电通电");}@Overridepublic void SocketService() {System.out.println("插排供电");}
}
​
public class TestElectric {
​public static void main(String[] args) {Computer com = new Computer();com.threeService();com.twoService();
//      IceBox  box = new IceBox();
//      box.threeService();
​}
​
}
class IceBox implements ThreeElectric{@Overridepublic void threeService() {System.out.println("冰箱进行三项电通电");}   
}
/*class Computer implements ThreeElectric,TwoElectric{@Overridepublic void twoService() {System.out.println("外置设备使用两项电通电");}@Overridepublic void threeService() {System.out.println("计算机使用三项电通电");}
}*/接口的成员：
interface Info{//成员  // public static final double PI = 3.14;// 静态方法 public // 静态方法：子接口 或 实现类是不能继承的static void sf() {System.out.println("sf");}// 默认方法 :对象调用default void df() {System.out.println("df");}
}
// 实现类                                       
class InfoImpl implements Info{public void  f() {System.out.println(PI);// Info.PI df();// Info.sf();// 静态方法}}
接口中存在了同名的成员：
interface IA{double PI = 3.14;static void sf() {}default void df() {}void af();
}
interface IB{double PI = 3.1415926;static void sf() {}default void df() {}void af();
}
class DemoImpl implements IA,IB{// 分开:匿名内部类 
/*  IA ia = new IA() {@Overridepublic void af() {// TODO Auto-generated method stub}
};
IB ib = new IB() {@Overridepublic void af() {// TODO Auto-generated method stub}
};*/
// 抽象方法
@Override
public void af() {// 代码
}
// 默认方法同名
@Override
public void df() {IA.super.df();IB.super.df();
}
public void func() {// 区分常量System.out.println(IA.PI);// System.out.println(IB.PI );// 静态方法IA.sf();IB.sf();// 
}  ​
​
}

3.接口和抽象类异同

相同点：
1) 都不能创建对象；
2）都可以定义抽象方法；
3） 普通的实现类或子类 必须 重写 实现父接口 或 父类中的所有抽象方法（抽象的
子类和实现类除外）
不同点:
定义:
抽象类: 类 ， 定义了 所有对象共同的特征和行为；
接口： 接口，一组功能的封装。
设计上：
接口:
同一个应用程序，不同的模块之间的耦合连接。
通过接口可以降低这个耦合连接。
鸟 ，鸵鸟， 飞（）
不同的程序：
程序之间通信的规则。

抽象类： 模板，
子类 ： 是子类组成的一部分。

五、多态

语法:(特征)

1） 方法重写。
2） 父类引用 -> 子类对象
接口引用 -> 实现类对象

多态应用：

1） 类 多态；
2） 接口多态；
3） 参数多态。

多态的好处：

1）屏蔽了子类的差异，更换 子类对象；
2.随意更换子类对象，程序不会 有任何影响；
3）一个父类类型 可以接收 所有的子类对象。

1.多态应用

类多态：

package day0919;

/**类多态*/
class Teacher{public void giveLesson() {System.out.println("讲数学课");}
}
class JavaTeacher extends Teacher{public void giveLesson() {System.out.println("讲Java课");}public void sing() {System.out.println("唱歌");}
}
class SqlTeacher extends Teacher{public void giveLesson() {System.out.println("讲Sql课");}public void dance() {System.out.println("跳舞");}
}
public class TestTeacher {
​public static void main(String[] args) {Teacher guofu = new JavaTeacher();System.out.println(guofu.getClass().getName());guofu.giveLesson();
//      guofu.sing();// 子类独特的功能调用不了。Teacher guoxiang = new SqlTeacher();guoxiang.giveLesson();
//      guoxiang.dance();
​}
​
}
​

接口多态：

package day0919;
​
/** 接口 多态*/
interface WebBank{// public abstract void webService();void webService() ;// 网上支付
}
// 实现类            实现                  接口class Jingdong implements WebBank{@Overridepublic void webService() {System.out.println("京东实现了网上支付功能");}   public void f() {}
}
class Taobao implements WebBank{@Overridepublic void webService() {System.out.println("淘宝实现了网上支付");}}
public class TestWebBank {
​public static void main(String[] args) {// 多态WebBank jd = new Jingdong();jd.webService();
//      jd.f();// 实现类 独特的功能被屏蔽了WebBank tb = new Taobao();tb.webService();}​
}

​

参数多态：

package day0919;
​
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);}@Overridepublic void eat() {System.out.println("小狗吃骨头");}public void run() {System.out.println("小狗跑了");}
}
class Cat extends Pet{public Cat(String name) {super(name);}@Overridepublic void eat() {System.out.println("小猫吃鱼");}public void play() {System.out.println("小猫去玩儿了");}
}
class PetHospital{// 看病                          多态                            Pet pet = xiaohua; Pet pet = new Cat();public void treatment (Pet pet) {// Pet pet = wangwang; Pet pet = new Dog();System.out.println("给：" + pet.getName() + "看病");pet.eat();if(pet instanceof Dog) {// true ,falseDog dog = (Dog)pet;// Pet  -> Dog dog.run();}else if(pet instanceof  Cat) {Cat cat = (Cat)pet;// (Cat)wangwangcat.play();}
//      pet.run();
//      pet.play();}}
public class TestHostpital {
​public static void main(String[] args) {Dog wangwang = new Dog("旺旺");Cat xiaohua = new Cat("小花");PetHospital hos = new PetHospital();// 医院hos.treatment(wangwang);hos.treatment(xiaohua);}
​
}
​

2.运算符

3.类型转换

六、UML之类图

建模语言。

1.泛化

继承。父类 和子类。从属。

类名: 抽象类，斜体。
属性：
访问修饰符:
private -
默认
protected #
public +
方法：

语法： class 子类 extends 父类{}

2.实现

接口 和 类。
语法： class 类 implements 接口，接口{}

3.依赖

使用。
语法：局部变量。

class Animal{public void eat(Food food){}}
class Food{
}

4.关联

拥有。
根据类的数量:
1.一对一： 1：1
2.一对多： 1：M
3.多对多： M:N

语法：成员变量

class Student{Subject subject = new Subject();
}
class Subject{}

聚集:强关联。

聚合：整体 和 局部，局部离开了整体可以独立存在。
语法：成员变量

class Car{Door [] door ;{door = new Door[2];for(int i = 0 ; i< door.length; i ++){door[i] = new Door();}}
}
class Door{}

组合:强聚集。

体现:整体 和 局部，局部离开了整体不能独立存在。
语法: 成员变量。

类图:

本文标签： 2019