Java面向对象

类和对象

类：对一类事物的描述，是抽象的、概念上的定义，具有属性和方法。
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。

1.方法

重载(overload)

方法参数的值传
可变个数的形参

2.对象的创建与对象的内存解析

举例1：

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
说明：
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
内存解析：

 

 

3、匿名对象

我们创建的对象，没显式的赋给一个变量名。即为匿名对象
特点：匿名对象只能调用一次。
举例：

public class CustomerTest3 {
    public static void main(String[] args) {
//        Customer c = new Customer();
//        c.sleep(2);
        new Customer().eat();//匿名对象调用方法
    }
}
class Customer{
    //属性
    String name;
    //方法
    public void eat(){
        System.out.println("客户吃饭");
    }
}
View Code

 

封装

1.为什么引入封装性？

我们程序设计追求“高内聚，低耦合”。
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.封装性思想代码体现？

  1. 将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
  2. 不对外暴露的私有的方法
  3. 单例模式（将构造器私有化）
  4. 如果不希望类在包外被调用，可以将类设置为缺省的。

3、权限修饰符

权限从小到大顺序为：private <  缺省 < protected < public

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类的话，只能使用：缺省、public；

继承

继承是使⽤已存在的类的定义作为基础建⽴新类的技术，新类的定义可以增加新的数据或新的功
能，也可以⽤⽗类的功能，但不能选择性地继承⽗类。

1.为什么要有类的继承性？(继承性的好处）
① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提
注意：

  • ⼦类拥有⽗类对象所有的属性和⽅法（包括私有属性和私有⽅法），但是⽗类中的私有属性和⽅法⼦类是⽆法访问，只是拥有。
  • ⼦类可以拥有⾃⼰属性和⽅法，即⼦类可以对⽗类进⾏扩展。
  • ⼦类可以重写⽗类的⽅法。
     

2.继承性的格式：
class A extends B{}
 *    A:子类、派生类、subclass
 *    B:父类、超类、基类、superclass

3.子类继承父类以后有哪些不同？
3.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
 *  特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已（可以通过get()方法获取）。

3.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。


4.Java中继承性的说明
1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法

多态

1.多态性的理解：可以理解为一个事物的多种形态。


2.何为多态性：
父类的引用指向子类的对象（或子类的对象赋给父类的引用）
举例：
Person p = new Man();
Object obj = new Date();


3.多态性的使用：虚拟方法调用
> 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
> 总结：编译，看左边；运行，看右边。


4.多态性的使用前提：
① 类的继承关系  ② 方法的重写


5.多态性的应用举例：
举例一：
    public void func(Animal animal){//Animal animal = new Dog();
        animal.eat();
        animal.shout();
    }
举例二：
public void method(Object obj){
        
    }
举例三：
class Driver{
    
    public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
        //规范的步骤去操作数据
//        conn.method1();
//        conn.method2();
//        conn.method3();
        
    }
    
}

6.多态性使用的注意点：
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）


7.关于向上转型与向下转型
7.1 向上转型：多态
7.2 向下转型：


7.2.1 为什么使用向下转型
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。


7.2.2 如何实现向下转型：
使用强制类型转换符：()


7.2.3 使用时的注意点：
① 使用强转时，可能出现ClassCastException的异常。
② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。


7.2.4 instanceof的使用：
① a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
③ 要求a所属的类与类A必须是子类和父类的关系，否则编译错误。
7.2.5 图示：

8. 面试题：
8.1 谈谈你对多态性的理解？
① 实现代码的通用性。
② Object类中定义的public boolean equals(Object obj){  }
  JDBC:使用java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server)
③ 抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）


8.2 多态是编译时行为还是运行时行为？

Object类的使用

1.java.lang.Object类的说明：

  1. Object类是所Java类的根父类
  2. 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
  3. Object类中的功能(属性、方法)就具通用性。属性：无。方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()、wait() 、 notify()、notifyAll()、。
  4. Object类只声明了一个空参的构造器

2.equals()方法
2.1 equals()的使用：
   1. 是一个方法，而非运算符
 * 2. 只能适用于引用数据类型
 * 3. Object类中equals()的定义：
 *    public boolean equals(Object obj) {
            return (this == obj);
      }
 *    说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
 *
 * 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
 *    两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
 *    
 * 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
 *    就需要对Object类中的equals()进行重写.
 *    重写的原则：比较两个对象的实体内容是否相同.


2.2 如何重写equals()
2.2.1 手动重写举例：
class User{
String name;
int age;
    //重写其equals()方法
    public boolean equals(Object obj){
        if(obj == this){
            return true;
        }
        if(obj instanceof User){
            User u = (User)obj;
            return this.age == u.age && this.name.equals(u.name);
        }
        return false;
    }
}
2.2.2 开发中如何实现：自动生成的


2.3 回顾 == 运算符的使用：
 * == ：运算符
 * 1. 可以使用在基本数据类型变量和引用数据类型变量中
 * 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
 *    如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
 * 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

3. toString()方法
3.1 toString()的使用：
   1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
 *
 * 2. Object类中toString()的定义：
 *   public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
     }
 *
 * 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。
 *    使得在调用对象的toString()时，返回"实体内容"信息
 *    
 * 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
3.2 如何重写toString()
举例：
//自动实现
    @Override
    public String toString() {
        return "Customer [name=" + name + ", age=" + age + "]";
    }

包装类的使用

1.为什么要有包装类(或封装类）
为了使基本数据类型的变量具有类的特征，引入包装类。

2.基本数据类型与对应的包装类：


3.需要掌握的类型间的转换：（基本数据类型、包装类、String）

 


简易版：

  • 基本数据类型<--->包装类：JDK 5.0 新特性：自动装箱 与自动拆箱
  • 基本数据类型、包装类->String:调用String重载的valueOf(Xxx xxx)
  • String->基本数据类型、包装类:调用包装类的parseXxx(String s)
  •      注意：转换时，可能会报NumberFormatException

应用场景举例：
① Vector类中关于添加元素，只定义了形参为Object类型的方法：
v.addElement(Object obj);   //基本数据类型 --->包装类 --->使用多态

关键字

this VS super

final\finally\finallize

final、finally、finalize的区别？

 

== 和 equals()

Static

1.可以用来修饰的结构：主要用来修饰类的内部结构(属性、方法、代码块、内部类)

 

2.static修饰属性：静态变量（或类变量）
        2.1 属性，是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
 *            实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
 *           静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
 *         2.2 static修饰属性的其他说明：
 *          ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
 *          ② 静态变量的加载要早于对象的创建。
 *          ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
 *          
 *          ④        类变量    实例变量
 *          类        yes        no
 *          对象    yes        yes
 *          
 *         2.3 静态属性举例：System.out; Math.PI;

 

3.静态变量内存解析：

 
4.static修饰方法：静态方法、类方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
②                      静态方法    非静态方法
 *          类            yes        　　 no
 *          对象        yes        　　yes
③ 静态方法中，只能调用静态的方法或属性
  非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5. static的注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

6.如何判定属性和方法应该使用static关键字：
6.1 关于属性
> 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
> 类中的常量也常常声明为static

6.2 关于方法
> 操作静态属性的方法，通常设置为static的
> 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections


7.使用举例：
举例一：Arrays、Math、Collections等工具类
举例二：单例模式

abstract

abstract: 抽象的
1.可以用来修饰：类、方法
2.具体的：
abstract修饰类：抽象类
 *      > 此类不能实例化
 *      > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
 *      > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 --->抽象的使用前提：继承性

abstract修饰方法：抽象方法
 *         > 抽象方法只方法的声明，没方法体
 *         > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
 *        > 若子类重写了父类中的所的抽象方法后，此子类方可实例化
 *          若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰


3.注意点：
 * 1.abstract不能用来修饰：属性、构造器等结构
 * 2.abstract不能用来修饰私方法、静态方法、final的方法、final的类


4.abstract的应用举例：
举例一：


举例二：
abstract class GeometricObject{
public abstract double findArea();
}
class Circle extends GeometricObject{
private double radius;
public double findArea(){
        return 3.14 * radius * radius;
};
}
举例三：IO流中设计到的抽象类：InputStream/OutputStream / Reader /Writer。在其内部
定义了抽象的read()、write()方法。

Interface

1.使用说明：
   1.接口使用interface来定义
 * 2.Java中，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口中的成员
 *         
 *         3.1 JDK7及以前：只能定义全局常量和抽象方法
 *             >全局常量：public static final的.但是书写时，可以省略不写
 *             >抽象方法：public abstract的
 *             
 *         3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略
 *
 * 4. 接口中不能定义构造器的！意味着接口不可以实例化
 *
 * 5. Java开发中，接口通过让类去实现(implements)的方式来使用.
 *    如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化
 *    如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类
 *    
 * 6. Java类可以实现多个接口   --->弥补了Java单继承性的局限性
 *   格式：class AA extends BB implements CC,DD,EE
 *   
 * 7. 接口与接口之间可以继承，而且可以多继承
 *
 * *******************************
 * 8. 接口的具体使用，体现多态性
 * 9. 接口，实际上可以看做是一种规范

2.举例：

 1 class Computer{
 2     public void transferData(USB usb){//USB usb = new Flash();
 3         usb.start();
 4         System.out.println("具体传输数据的细节");
 5         usb.stop();
 6     }
 7 }
 8 
 9 interface USB{
10     //常量：定义了长、宽、最大最小的传输速度等
11     void start();
12     void stop();
13 }
14 
15 class Flash implements USB{
16     @Override
17     public void start() {
18         System.out.println("U盘开启工作");
19     }
20 
21     @Override
22     public void stop() {
23         System.out.println("U盘结束工作");
24     }
25 }
26 
27 class Printer implements USB{
28     @Override
29     public void start() {
30         System.out.println("打印机开启工作");
31     }
32 
33     @Override
34     public void stop() {
35         System.out.println("打印机结束工作");
36     }
37 }
View Code


体会：
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！    


3.体会面向接口编程的思想

面向接口编程：我们在应用程序中，调用的结构都是JDBC中定义的接口，不会出现具体某一个
数据库厂商的API。


4.Java8中关于接口的新规范
//知识点1：接口中定义的静态方法，只能通过接口来调用。

//知识点2：通过实现类的对象，可以调用接口中的默认方法。
//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法

//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//那么在实现类没重写此方法的情况下，报错。-->接口冲突。
//这就需要我们必须在实现类中重写此方法
//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
    public void myMethod(){
        method3();//调用自己定义的重写的方法
        super.method3();//调用的是父类中声明的
        //调用接口中的默认方法
        CompareA.super.method3();
        CompareB.super.method3();
    }


5.面试题：
抽象类和接口的异同？
相同点：不能实例化；都可以包含抽象方法的。
不同点：
1）把抽象类和接口(java7,java8,java9)的定义、内部结构解释说明
2）类：单继承性    接口：多继承
   类与接口：多实现


 

涉及垃圾回收的说明

垃圾回收机制关键点

垃圾回收机制只回收JVM堆内存里的对象空间。

对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力

现在的JVM有多种垃圾回收实现算法，表现各异。

垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行。

可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。

程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，但是系统是否进行垃圾回收依然不确定。

垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。

永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

posted @ 2021-04-05 12:35  冰河入梦~  阅读(324)  评论(0)  编辑  收藏  举报