【Java】面向对象编程（包/ 继承/ 组合/ 多态/ 抽象类/ 接口）

一、包
（1）包：文件夹
命名：
a.小写字母并采用公司网站
b.倒叙: www.baidu.com——>com.baidu.www

public class Test {    
  public static void main(String[] args) {      
    java.util.Date date = new java.util.Date(); //得到一个毫秒级别的时间戳 
       System.out.println(date.getTime());    
  }
   }

以上代码可以使用 import 语句（简单）导入包：

import java.util.Date; public class Test {   
 public static void main(String[] args) {      
     Date date = new Date(); //得到一个毫秒级别的时间戳        
     System.out.println(date.getTime());    
   } 
 }

【用谁就导入谁】

import java.util.*; 
import java.sql.*; 
public class Test {    
public static void main(String[] args) {        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错       
 Date date = new Date();        System.out.println(date.getTime());    
   } 
}

此时编译出错：对Date的引用不明确，java.sql 中的类，java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

（2）包的访问权限控制：
public private protected 默认只能访问包当中的类。

(3) 常见的系统包：

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reﬂect:java 反射编程包;
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

二、.opp: 继承封装多态

1.继承（is a）：为了代码的复用

a.子类/派生类 extends 父类/基类/超类：如果要构造子类，必须先构造父类

class 子类 extends 父类 {     
 }

b.子类继承父类：继承除构造方法以外的所有东西，帮助父类构造。

c. super()：调用父类的构造方法，必须放在第一行。
super.data;
super.func();
super();

super与this的区别
在这里插入图片描述
父类只能访问自己的成员和方法，但是可以通过子类访问父类的；

d. Animal: protected name
只有继承了Animal类（cat类）的才可以访问name

前提：必须是public的类

Java 中对于字段和方法共有四种访问权限：
1.private: 类内部能访问, 类外部不能访问。
2.默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问。
3.protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问。
4.public : 类内部和类的调用者都能访问。
在这里插入图片描述

e.Java单继承。

f.多层继承:子类还可以进一步的再派生出新的子类.

g. final:
final class person 密封类/不能被继承

h. 代码块：static：静态类只出现一次（静态实例构造方法）

2.组合（has a/a part of 什么是什么的一部分):能够达到代码重用的效果.

例如表示一个学校:

public class Student {    
         ... 
 } 
 
public class Teacher {    
         ... 
 } 
 
public class School {     
public Student[] students;     
public Teacher[] teachers;
 }

3.多态
向上转型：父类引用子类对象：
Animal a=new Cat（）: Animal父类只能调用自己的方法或者成员属性

     invokespecial 构造方法 
     Invokevirtual 非静态方法 实例方法:      编译的时候调用的确实是animal方法，但是运行出来时cat的方法
             
     Invokestatic  静态方法

方法不能是private。
子类的方法权限一定要大于父类的方法权限。public>protected>default>private
不能是静态方法static。
重写override（覆盖）：方法名相同，参数列表相同，返回值相同
重载overload：方法名相同，参数列表不同，返回值不作要求

发生多态 (运行时绑定) ：

1.继承：父类需要引用子类对象（向上转型）。
2.通过父类的引用，去调用子类和父类同名的覆盖（重写）方法。
Animal animal=new Cat（）； animal.eat()；

 结果以为出来的是Animal的eat,结果是cat的eat

3.class对象在方法区：获取class对象有3种，其地址相同。运行多态时，底层的地址悄悄更换了。

==向下转型 ==
父类给子类：
Bird bird = (Bird)animal; bird.fly();//把animal给bird了

    前提：必须先进行一次向上转型. 例如：只new Cat ,Bird没有实例

1.构造方法内，可以发生运行时绑定。
2.在构造子类时，会调用父类的构造方法，父类的构造方法。
，
使用多态的好处是什么?

类调用者对类的使用成本进一步降低.
封装是让类的调用者不需要知道类的实现细节.
多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可.
能够降低代码的 “圈复杂度”, 避免使用大量的 if – else（不超过10个）

4.抽象类

abstract class Shape {     
abstract public void draw(); 
}

抽象类：包含抽象的方法。
抽象类不能直接实例化. new。
抽象类当中可以有抽象方法，也可以有非抽象方法或成员变量。
抽象类是为了继承的。继承之后，一定要重写。
抽象类A如果继承了抽象类B，那么抽象类A可以选择重写或者不重写抽象类B中的方法。
抽象类A如果重写了，那么类C继承A时，不用重写。
抽象方法不能是 private的。

5.接口

interface IShape {     
（public abstract加不加都无所谓，一般不加）void draw(); 
}

接口的关键字interface
接口当中的方法全部不能有具体的实现
接口当中的方法都是抽象方法（可以省略abstract），是默认的public abstract（可省略）
阿里巴巴：接口当中的方法尽量简洁
接口当中的成员变量都是public static final
接口是不能被实例化的 new
类和接口之间的关系需要实现implements，只要普通类实现这个接口，那么接口当中的方法必须重写
接口和接口之间是继承 extends
继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性 .
一个类继承一个父类, 同时实现多种接口继承在先实现在后

抽象类与接口的区别

<两个重要接口>

1.自定义类型比较需要实现接口，实现Comparable接口，重写compareTo方法。

2.空接口(标记接口)：标志当前类可以克隆Cloneable，重写时注意抛出异常。
在这里插入图片描述
扩展(extends) vs 实现(implements)：
1.扩展指的是当前已经有一定的功能了, 进一步扩充功能.
2.实现指的是当前啥都没有, 需要从头构造出来.

最妹妹的妹妹

发布了20 篇原创文章 · 获赞 23 · 访问量 566

私信关注

【Java】面向对象编程（包/ 继承/ 组合/ 多态/ 抽象类/ 接口）

猜你喜欢