文章目录

Object类
一、final
- 修饰：类，方法，变量；
二、实现关系
三、抽象类
四、接口
五、多态
六、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{// 父类 Object
    private int age;
    public Employee(int age) {
        this.age = age;
    }
    public int show() {
        return age;
    }
/*  @Override
    public 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;
    }
    */
    // 系统自动生成的代码
    @Override
    public boolean equals(Object obj) {
        // this->guojing  obj ->yangkang 
        if (this == obj)// guojing.equals(guojing) age
            return true;
        if (obj == null)// guojing.equals(null) false
            return false;
        // guojing.getClass();
        if (this.getClass() != obj.getClass())// guojing.equals("hello")  -> Employee : String
            return 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;
	}
	@Override
	public 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;
    }
/*  @Override
    public int hashCode() {
        return no;
    }*/
    @Override
    public 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.Demo
    Object demo = new Demo();
    
    System.out.println(demo.getClass());// 获得字节码文件对应的对象
    // day0810.Demo
    System.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;
    }*/

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return 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@15db9742
        System.out.println(guojing);// 隐式调用toString
//      System.out.println(guojing.toString());// 显示调用toString()

    }

}

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

class Teacher{
	int no;
	@Override
	protected 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{
    @Override
    public void webService() {
        System.out.println("京东实现了网上支付功能");
    }   
}
class Taobao implements WebBank{
    @Override
    public 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{ 
    @Override
    public void twoService() {
        System.out.println("外置设备使用两项电通电");
    }
    @Override
    public void threeService() {
        System.out.println("计算机使用三项电通电");
    }
    @Override
    public 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{
    @Override
    public void threeService() {
        System.out.println("冰箱进行三项电通电");
    }   
}
/*class Computer implements ThreeElectric,TwoElectric{
    @Override
    public void twoService() {
        System.out.println("外置设备使用两项电通电");
    }
    @Override
    public 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() {
    
    @Override
    public void af() {
        // TODO Auto-generated method stub
        
    }
};
IB ib = new IB() {
    
    @Override
    public 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{
    @Override
    public void webService() {
        System.out.println("京东实现了网上支付功能");
    }   
    public void f() {}
}
class Taobao implements WebBank{
    @Override
    public 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);
    }
    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
    public void run() {
        System.out.println("小狗跑了");
    }
}
class Cat extends Pet{
    public Cat(String name) {
        super(name);
    }
    @Override
    public 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 ,false
            Dog dog = (Dog)pet;// Pet  -> Dog 
            dog.run();
        }else if(pet instanceof  Cat) {
    
        Cat cat = (Cat)pet;// (Cat)wangwang
        cat.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{
    
}

组合:强聚集。

体现:整体和局部，局部离开了整体不能独立存在。

语法: 成员变量。

类图:
在这里插入图片描述

原文链接：https://blog.csdn.net/weixin_45505750/article/details/100906982

文章目录

Object类

1.equals()

hashCode()：hash算法

toString():

一、final

修饰： 类 ，方法，变量；

类： 此类不能被继承；

方法：不能被重写；

变量: 常量。

使用常量好处:

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

二、实现关系

三、抽象类

分析：

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

注意：

四、接口

1.语法JDK8.0

2.接口特点：

3.接口和抽象类异同

五、多态

语法:(特征)

多态应用：

多态的好处：

1.多态应用

类多态：

接口多态：

参数多态：

2.运算符

3.类型转换

六、UML之类图

1.泛化

2.实现

3.依赖

4.关联

你可能也喜欢

修饰：类，方法，变量；

类：此类不能被继承；

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